drygdryg/wpspin-nim
1
0
Fork 0
mirror of https://github.com/drygdryg/wpspin-nim.git synced 2025-04-18 16:02:57 +03:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: drygdryg:0.3.0
Branches Tags
drygdryg:master
drygdryg:0.5.1
drygdryg:0.5.0
drygdryg:0.3.0
...
compare: drygdryg:master
Branches Tags
drygdryg:master
drygdryg:0.5.1
drygdryg:0.5.0
drygdryg:0.3.0

5 Commits
0.3.0 ... master

Author SHA1 Message Date
Victor
cf7f800030
Code style changes 2021-03-31 16:27:00 +03:00
Victor Golovanenko
0f804b0d5c
Makefile: accept all Nimble interactive prompts 2021-02-08 18:10:19 +03:00
Victor Golovanenko
901283761d
Reverse byte 24-bit PIN: added MACs 
for Trendnet TEW-818DRU and Trendnet TEW-828DRU
References:
https://packetstormsecurity.com/files/132477/TRENDnet-TEW-818RDU-PIN-Disclosure.html
https://github.com/kcdtv/tdn/blob/master/tdn.sh
 2021-02-04 08:28:53 +03:00
Victor Golovanenko
f1a40fc40c
Build with Nimble 2021-02-04 08:15:38 +03:00
Victor Golovanenko
666ffe6517
Updated argparse, added properly checks for MAC address 2021-02-04 08:06:34 +03:00
5 changed files with 214 additions and 214 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1 +0,0 @@
*.nims

4
Makefile
View File

@ -9,10 +9,8 @@ SOURCE = $(SRCDIR)/wpspin.nim
all: $(TARGET) all: $(TARGET)
$(TARGET): $(SOURCE) $(TARGET): $(SOURCE)
nimble install -y argparse nimble build -y -d:release
nim compile --gc:none --checks:off --out:$@ $(SOURCE)
strip $@ strip $@
nimble uninstall -y argparse
install: $(TARGET) install: $(TARGET)
install -d $(BINDIR) install -d $(BINDIR)

414
src/wpspin.nim
View File

@ -1,8 +1,20 @@
import std / [strutils, strformat, json] import std / [strutils, strformat, json, sequtils]
const mac_separators_replace = {"-": ":", ".": ":"}
const mac_separators_remove = {":": "", "-": "", ".": ""} const mac_separators_remove = {":": "", "-": "", ".": ""}
type AlgorithmMode = enum
ALGO_MAC,
ALGO_EMPTY,
ALGO_STATIC
type Algorithm = object
id: string
name: string
mode: AlgorithmMode
mac_substr: seq[string]
generator: proc(mac: string): string
proc reverse(input: string): string = proc reverse(input: string): string =
result = "" result = ""
for index in countdown(input.high, 0): for index in countdown(input.high, 0):
@ -27,166 +39,6 @@ proc add_checksum(pin: uint32): int = int(pin) * 10 + pin_checksum(pin)
proc finalize_pin(pin: uint32): string = intToStr(add_checksum(pin), 8) proc finalize_pin(pin: uint32): string = intToStr(add_checksum(pin), 8)
proc pin24(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint32](mac_str[6..11]) mod 10_000_000))
proc pin28(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint32](mac_str[5..11]) mod 10_000_000))
proc pin32(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint32](mac_str[4..11]) mod 10_000_000))
proc pin36(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint64](mac_str[3..11]) mod 10_000_000))
proc pin40(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint64](mac_str[2..11]) mod 10_000_000))
proc pin44(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint64](mac_str[1..11]) mod 10_000_000))
proc pin48(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint64](mac_str) mod 10_000_000))
proc pin24rh(mac: string): string =
let t = mac.multiReplace(mac_separators_remove)[6..11]
finalize_pin(uint32(fromHex[uint32](t[4..5] & t[2..3] & t[0..1]) mod 10_000_000))
proc pin32rh(mac: string): string =
let t = mac.multiReplace(mac_separators_remove)[4..11]
finalize_pin(uint32(fromHex[uint32](t[6..7] & t[4..5] & t[2..3] & t[0..1]) mod 10_000_000))
proc pin48rh(mac: string): string =
let t = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint64](t[10..11] & t[8..9] & t[6..7] & t[4..5] & t[2..3] & t[0..1]) mod 10_000_000))
proc pin24rn(mac: string): string =
finalize_pin(fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11].reverse()) mod 10_000_000)
proc pin32rn(mac: string): string =
finalize_pin(fromHex[uint32](mac.multiReplace(mac_separators_remove)[4..11].reverse()) mod 10_000_000)
proc pin48rn(mac: string): string =
finalize_pin(uint32(fromHex[uint64](mac.multiReplace(mac_separators_remove).reverse()) mod 10_000_000))
proc pin24rb(mac: string): string =
let t = fromHex[BiggestInt](mac.multiReplace(mac_separators_remove)[6..11])
finalize_pin(uint32(fromBin[uint32](t.toBin(24).reverse()) mod 10_000_000))
proc pin32rb(mac: string): string =
let t = fromHex[BiggestInt](mac.multiReplace(mac_separators_remove)[4..11])
finalize_pin(uint32(fromBin[uint32](t.toBin(32).reverse()) mod 10_000_000))
proc pin48rb(mac: string): string =
let t = fromHex[BiggestInt](mac.multiReplace(mac_separators_remove))
finalize_pin(uint32(fromBin[uint64](t.toBin(48).reverse()) mod 10_000_000))
proc pinDLink(mac: string): string =
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
var pin: uint32 = nic xor 0x55AA55
pin = pin xor (((pin and 0xF) shl 4) +
((pin and 0xF) shl 8) +
((pin and 0xF) shl 12) +
((pin and 0xF) shl 16) +
((pin and 0xF) shl 20))
pin = pin mod 10_000_000
if pin < 1000000:
pin += ((pin mod 9) * 1000000) + 1000000
return finalize_pin(pin)
proc pinDLink1(mac: string): string =
var nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
var pin: uint32 = (nic + 1) xor 0x55AA55
pin = pin xor (((pin and 0xF) shl 4) +
((pin and 0xF) shl 8) +
((pin and 0xF) shl 12) +
((pin and 0xF) shl 16) +
((pin and 0xF) shl 20))
pin = pin mod 10_000_000
if pin < 1000000:
pin += ((pin mod 9) * 1000000) + 1000000
return finalize_pin(pin)
proc pinASUS(mac: string): string =
var b: array[6, uint16]
var i: int = 0
for e in mac.split(':'):
b[i] = fromHex[uint16](e)
i.inc()
var pin_code: string = ""
for i in 0'u16..<7'u16:
pin_code.addInt int((b[i mod 6] + b[5]) mod (10'u16 - (i + b[1] + b[2] + b[
3] + b[4] + b[5]) mod 7'u16))
return finalize_pin(uint32(parseInt(pin_code)))
proc pinAirocon(mac: string): string =
var b: array[6, uint32]
var i: int = 0
for e in mac.split(':'):
b[i] = fromHex[uint32](e)
i.inc()
let pin = ((b[0] + b[1]) mod 10'u32) +
(((b[5] + b[0]) mod 10) * 10'u32) +
(((b[4] + b[5]) mod 10) * 100'u32) +
(((b[3] + b[4]) mod 10) * 1000'u32) +
(((b[2] + b[3]) mod 10) * 10000'u32) +
(((b[1] + b[2]) mod 10) * 100000'u32) +
(((b[0] + b[1]) mod 10) * 1000000'u32)
return finalize_pin(pin)
proc pinInvNIC(mac: string): string =
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
return finalize_pin(uint32((not nic and 0xFFFFFF) mod 10_000_000))
proc pinNIC2(mac: string): string =
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
return finalize_pin(uint32((nic * 2) mod 10_000_000))
proc pinNIC3(mac: string): string =
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
return finalize_pin(uint32((nic * 3) mod 10_000_000))
proc pinOUIsubNIC(mac: string): string =
let oui = fromHex[uint32](mac.multiReplace(mac_separators_remove)[0..5])
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
var pin: uint32
if nic < oui:
pin = oui - nic
else:
pin = (oui + 0x1000000 - nic) and 0xFFFFFF
return finalize_pin(pin mod 10_000_000)
proc pinOUIaddNIC(mac: string): string =
let oui = fromHex[uint32](mac.multiReplace(mac_separators_remove)[0..5])
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
return finalize_pin(((oui + nic) mod 0x1000000) mod 10_000_000)
proc pinOUIxorNIC(mac: string): string =
let oui = fromHex[uint32](mac.multiReplace(mac_separators_remove)[0..5])
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
return finalize_pin((oui xor nic) mod 10_000_000)
type AlgorithmMode = enum
ALGO_MAC,
ALGO_EMPTY,
ALGO_STATIC
type Algorithm = object
id: string
name: string
mode: AlgorithmMode
mac_substr: seq[string]
generator: proc(mac: string): string
const algorithms = [ const algorithms = [
Algorithm( Algorithm(
id: "pin24", id: "pin24",
@ -212,14 +64,20 @@ const algorithms = [
"72E87B", "0026CE", "9897D1", "E04136", "B246FC", "E24136", "00E020", "72E87B", "0026CE", "9897D1", "E04136", "B246FC", "E24136", "00E020",
"5CA39D", "D86CE9", "DC7144", "801F02", "E47CF9", "000CF6", "00A026", "5CA39D", "D86CE9", "DC7144", "801F02", "E47CF9", "000CF6", "00A026",
"A0F3C1", "647002", "B0487A", "F81A67", "F8D111", "34BA9A", "B4944E"], "A0F3C1", "647002", "B0487A", "F81A67", "F8D111", "34BA9A", "B4944E"],
generator: pin24 generator:
proc(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint32](mac_str[6..11]) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin28", id: "pin28",
name: "28-bit PIN", name: "28-bit PIN",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @["200BC7", "4846FB", "D46AA8", "F84ABF"], mac_substr: @["200BC7", "4846FB", "D46AA8", "F84ABF"],
generator: pin28 generator:
proc(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint32](mac_str[5..11]) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin32", id: "pin32",
@ -228,98 +86,143 @@ const algorithms = [
mac_substr: @["000726", "D8FEE3", "FC8B97", "1062EB", "1C5F2B", "48EE0C", mac_substr: @["000726", "D8FEE3", "FC8B97", "1062EB", "1C5F2B", "48EE0C",
"802689", "908D78", "E8CC18", "2CAB25", "10BF48", "14DAE9", "3085A9", "802689", "908D78", "E8CC18", "2CAB25", "10BF48", "14DAE9", "3085A9",
"50465D", "5404A6", "C86000", "F46D04", "3085A9", "801F02"], "50465D", "5404A6", "C86000", "F46D04", "3085A9", "801F02"],
generator: pin32 generator:
proc(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint32](mac_str[4..11]) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin36", id: "pin36",
name: "36-bit PIN", name: "36-bit PIN",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin36 generator:
proc(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint64](mac_str[3..11]) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin40", id: "pin40",
name: "40-bit PIN", name: "40-bit PIN",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin40 generator:
proc(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint64](mac_str[2..11]) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin44", id: "pin44",
name: "44-bit PIN", name: "44-bit PIN",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin44 generator:
proc(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint64](mac_str[1..11]) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin48", id: "pin48",
name: "48-bit PIN", name: "48-bit PIN",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin48 generator:
proc(mac: string): string =
let mac_str = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint64](mac_str) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin24rh", id: "pin24rh",
name: "Reverse byte 24-bit", name: "Reverse byte 24-bit",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @["D8EB97", "0014D1", "3C8CF8"],
generator: pin24rh generator:
proc(mac: string): string =
let t = mac.multiReplace(mac_separators_remove)[6..11]
finalize_pin(uint32(fromHex[uint32](t[4..5] & t[2..3] & t[
0..1]) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin32rh", id: "pin32rh",
name: "Reverse byte 32-bit", name: "Reverse byte 32-bit",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin32rh generator:
proc(mac: string): string =
let t = mac.multiReplace(mac_separators_remove)[4..11]
finalize_pin(uint32(fromHex[uint32](t[6..7] & t[4..5] & t[2..3] & t[
0..1]) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin48rh", id: "pin48rh",
name: "Reverse byte 48-bit", name: "Reverse byte 48-bit",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin48rh generator:
proc(mac: string): string =
let t = mac.multiReplace(mac_separators_remove)
finalize_pin(uint32(fromHex[uint64](t[10..11] & t[8..9] & t[6..7] & t[
4..5] & t[2..3] & t[0..1]) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin24rn", id: "pin24rn",
name: "Reverse nibble 24-bit", name: "Reverse nibble 24-bit",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin24rn generator:
proc(mac: string): string =
finalize_pin(fromHex[uint32](mac.multiReplace(mac_separators_remove)[
6..11].reverse()) mod 10_000_000)
), ),
Algorithm( Algorithm(
id: "pin32rn", id: "pin32rn",
name: "Reverse nibble 32-bit", name: "Reverse nibble 32-bit",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin32rn generator:
proc(mac: string): string =
finalize_pin(fromHex[uint32](mac.multiReplace(mac_separators_remove)[
4..11].reverse()) mod 10_000_000)
), ),
Algorithm( Algorithm(
id: "pin48rn", id: "pin48rn",
name: "Reverse nibble 48-bit", name: "Reverse nibble 48-bit",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin48rn generator:
proc(mac: string): string =
finalize_pin(uint32(fromHex[uint64](mac.multiReplace(
mac_separators_remove).reverse()) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin24rb", id: "pin24rb",
name: "Reverse bits 24-bit", name: "Reverse bits 24-bit",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin24rb generator:
proc(mac: string): string =
let t = fromHex[BiggestInt](mac.multiReplace(mac_separators_remove)[6..11])
finalize_pin(uint32(fromBin[uint32](t.toBin(24).reverse()) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin32rb", id: "pin32rb",
name: "Reverse bits 32-bit", name: "Reverse bits 32-bit",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin32rb generator:
proc(mac: string): string =
let t = fromHex[BiggestInt](mac.multiReplace(mac_separators_remove)[4..11])
finalize_pin(uint32(fromBin[uint32](t.toBin(32).reverse()) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pin48rb", id: "pin48rb",
name: "Reverse bits 48-bit", name: "Reverse bits 48-bit",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pin48rb generator:
proc(mac: string): string =
let t = fromHex[BiggestInt](mac.multiReplace(mac_separators_remove))
finalize_pin(uint32(fromBin[uint64](t.toBin(48).reverse()) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pinDLink", id: "pinDLink",
@ -327,7 +230,19 @@ const algorithms = [
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @["14D64D", "1C7EE5", "28107B", "84C9B2", "A0AB1B", "B8A386", mac_substr: @["14D64D", "1C7EE5", "28107B", "84C9B2", "A0AB1B", "B8A386",
"C0A0BB", "CCB255", "FC7516", "0014D1", "D8EB97"], "C0A0BB", "CCB255", "FC7516", "0014D1", "D8EB97"],
generator: pinDLink generator:
proc(mac: string): string =
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
var pin: uint32 = nic xor 0x55AA55
pin = pin xor (((pin and 0xF) shl 4) +
((pin and 0xF) shl 8) +
((pin and 0xF) shl 12) +
((pin and 0xF) shl 16) +
((pin and 0xF) shl 20))
pin = pin mod 10_000_000
if pin < 1000000:
pin += ((pin mod 9) * 1000000) + 1000000
return finalize_pin(pin)
), ),
Algorithm( Algorithm(
id: "pinDLink1", id: "pinDLink1",
@ -336,7 +251,19 @@ const algorithms = [
mac_substr: @["0018E7", "00195B", "001CF0", "001E58", "002191", "0022B0", mac_substr: @["0018E7", "00195B", "001CF0", "001E58", "002191", "0022B0",
"002401", "00265A", "14D64D", "1C7EE5", "340804", "5CD998", "84C9B2", "002401", "00265A", "14D64D", "1C7EE5", "340804", "5CD998", "84C9B2",
"B8A386", "C8BE19", "C8D3A3", "CCB255", "0014D1"], "B8A386", "C8BE19", "C8D3A3", "CCB255", "0014D1"],
generator: pinDLink1 generator:
proc(mac: string): string =
var nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
var pin: uint32 = (nic + 1) xor 0x55AA55
pin = pin xor (((pin and 0xF) shl 4) +
((pin and 0xF) shl 8) +
((pin and 0xF) shl 12) +
((pin and 0xF) shl 16) +
((pin and 0xF) shl 20))
pin = pin mod 10_000_000
if pin < 1000000:
pin += ((pin mod 9) * 1000000) + 1000000
return finalize_pin(pin)
), ),
Algorithm( Algorithm(
id: "pinASUS", id: "pinASUS",
@ -359,7 +286,18 @@ const algorithms = [
"EC4C4D", "F42853", "F43E61", "F46BEF", "F8AB05", "FC8B97", "7062B8", "EC4C4D", "F42853", "F43E61", "F46BEF", "F8AB05", "FC8B97", "7062B8",
"78542E", "C0A0BB8C", "C412F5", "C4A81D", "E8CC18", "EC2280", "78542E", "C0A0BB8C", "C412F5", "C4A81D", "E8CC18", "EC2280",
"F8E903F4"], "F8E903F4"],
generator: pinASUS generator:
proc(mac: string): string =
var b: array[6, uint16]
var i: int = 0
for e in mac.split(':'):
b[i] = fromHex[uint16](e)
i.inc()
var pin_code: string = ""
for i in 0'u16..<7'u16:
pin_code.addInt int((b[i mod 6] + b[5]) mod (10'u16 - (i + b[1] + b[2] +
b[3] + b[4] + b[5]) mod 7'u16))
return finalize_pin(uint32(parseInt(pin_code)))
), ),
Algorithm( Algorithm(
id: "pinAirocon", id: "pinAirocon",
@ -369,49 +307,89 @@ const algorithms = [
"001AEF", "00E04BB3", "02101801", "0810734", "08107710", "1013EE0", "001AEF", "00E04BB3", "02101801", "0810734", "08107710", "1013EE0",
"2CAB25C7", "788C54", "803F5DF6", "94FBB2", "BC9680", "F43E61", "2CAB25C7", "788C54", "803F5DF6", "94FBB2", "BC9680", "F43E61",
"FC8B97"], "FC8B97"],
generator: pinAirocon generator:
proc(mac: string): string =
var b: array[6, uint32]
var i: int = 0
for e in mac.split(':'):
b[i] = fromHex[uint32](e)
i.inc()
let pin = ((b[0] + b[1]) mod 10'u32) +
(((b[5] + b[0]) mod 10) * 10'u32) +
(((b[4] + b[5]) mod 10) * 100'u32) +
(((b[3] + b[4]) mod 10) * 1000'u32) +
(((b[2] + b[3]) mod 10) * 10000'u32) +
(((b[1] + b[2]) mod 10) * 100000'u32) +
(((b[0] + b[1]) mod 10) * 1000000'u32)
return finalize_pin(pin)
), ),
Algorithm( Algorithm(
id: "pinInvNIC", id: "pinInvNIC",
name: "Inv NIC to PIN", name: "Inv NIC to PIN",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pinInvNIC generator:
proc(mac: string): string =
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
return finalize_pin(uint32((not nic and 0xFFFFFF) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pinNIC2", id: "pinNIC2",
name: "NIC * 2", name: "NIC * 2",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pinNIC2 generator:
proc(mac: string): string =
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
return finalize_pin(uint32((nic * 2) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pinNIC3", id: "pinNIC3",
name: "NIC * 3", name: "NIC * 3",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pinNIC3 generator:
proc(mac: string): string =
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
return finalize_pin(uint32((nic * 3) mod 10_000_000))
), ),
Algorithm( Algorithm(
id: "pinOUIaddNIC", id: "pinOUIaddNIC",
name: "OUI + NIC", name: "OUI + NIC",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pinOUIaddNIC generator:
proc(mac: string): string =
let oui = fromHex[uint32](mac.multiReplace(mac_separators_remove)[0..5])
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
return finalize_pin(((oui + nic) mod 0x1000000) mod 10_000_000)
), ),
Algorithm( Algorithm(
id: "pinOUIsubNIC", id: "pinOUIsubNIC",
name: "OUI - NIC", name: "OUI - NIC",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pinOUIsubNIC generator:
proc(mac: string): string =
let oui = fromHex[uint32](mac.multiReplace(mac_separators_remove)[0..5])
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
var pin: uint32
if nic < oui:
pin = oui - nic
else:
pin = (oui + 0x1000000 - nic) and 0xFFFFFF
return finalize_pin(pin mod 10_000_000)
), ),
Algorithm( Algorithm(
id: "pinOUIxorNIC", id: "pinOUIxorNIC",
name: "OUI ^ NIC", name: "OUI ^ NIC",
mode: ALGO_MAC, mode: ALGO_MAC,
mac_substr: @[], mac_substr: @[],
generator: pinOUIxorNIC generator:
proc(mac: string): string =
let oui = fromHex[uint32](mac.multiReplace(mac_separators_remove)[0..5])
let nic = fromHex[uint32](mac.multiReplace(mac_separators_remove)[6..11])
return finalize_pin((oui xor nic) mod 10_000_000)
), ),
Algorithm( Algorithm(
id: "pinEmpty", id: "pinEmpty",
@ -636,6 +614,20 @@ proc generateAll(mac: string, testing: bool = false): seq[PinCode] =
) )
return pins return pins
proc prepareMac(mac: string): string =
## Checks if MAC address is valid and prepares it. Takes a MAC address without separators.
## Returns prepared MAC address with a ":" separator if it's valid, otherwise an empty string.
var prepared_mac = mac.multiReplace(mac_separators_remove)
if prepared_mac.len != 12:
return ""
if not all(prepared_mac, proc(c: char): bool = c in
HexDigits): # Checks if each char of prepared_mac is hexdigit
return ""
prepared_mac = prepared_mac.toUpperAscii()
for i in countdown(10, 2, 2):
prepared_mac.insert(":", i)
return prepared_mac
when is_main_module: when is_main_module:
import argparse import argparse
@ -644,29 +636,35 @@ when is_main_module:
help("WPS PIN generator which uses known MAC address based algorithms commonly found in Wi-Fi routers firmware to generate their default PINs.") help("WPS PIN generator which uses known MAC address based algorithms commonly found in Wi-Fi routers firmware to generate their default PINs.")
flag("-A", "--gen-all", help = "generate all PIN codes in addition to the suggested ones") flag("-A", "--gen-all", help = "generate all PIN codes in addition to the suggested ones")
flag("-J", "--json", help = "return results in JSON representation") flag("-J", "--json", help = "return results in JSON representation")
flag("-T", "--gen-testing", help="generate pin codes obtained by algorithms for testing (no use cases on real devices)") flag("-T", "--gen-testing", help = "generate pin codes obtained by algorithms for testing (no use cases on real devices)")
arg("mac", help = "target MAC address to generate PIN code. Example: 11:22:33:44:55:66 or 11-22-33-44-55-66") arg("mac", help = "target MAC address to generate PIN code. Example: 11:22:33:44:55:66 or 11-22-33-44-55-66")
try: try:
let args = p.parse() let args = p.parse(commandLineParams())
if (args.mac != "") and (not args.help): let mac = prepareMac(args.mac)
let mac = args.mac.multiReplace(mac_separators_replace).toUpperAscii() if mac == "":
let pins = if args.gen_all: generateAll(mac, args.gen_testing) else: generateSuggested(mac) echo &"Error: \"{args.mac}\" isn't a valid MAC address"
if args.json: quit(1)
echo $(%*pins) let pins = if args.gen_all: generateAll(mac,
else: args.gen_testing) else: generateSuggested(mac)
if pins.len != 0: if args.json:
if not args.gen_all: echo $(%*pins)
echo &"Found {pins.len} PIN(s)" else:
echo &"""{"PIN":<8} {"Name"}""" if pins.len != 0:
if not args.gen_all:
echo &"Found {pins.len} PIN(s)"
echo &"""{"PIN":<8} {"Name"}"""
for pin in pins: for pin in pins:
let pin_name = if pin.mode == ALGO_STATIC: "Static PIN -- " & let pin_name = if pin.mode == ALGO_STATIC: "Static PIN -- " &
pin.name else: pin.name pin.name else: pin.name
let pin_value = if pin.mode == ALGO_EMPTY: "<empty>" else: pin.pin let pin_value = if pin.mode == ALGO_EMPTY: "<empty>" else: pin.pin
echo &"{pin_value:<8} | {pin_name}" echo &"{pin_value:<8} | {pin_name}"
else: else:
echo "No PINs found -- try to get all PINs (-A)" echo "No PINs found -- try to get all PINs (-A)"
except ShortCircuit as e:
if e.flag == "argparse_help":
quit(p.help)
except UsageError: except UsageError:
echo "Error: invalid arguments. Use -h to get help" echo "Error: invalid arguments. Use -h to get help"
quit(QuitFailure) quit(QuitFailure)

5
src/wpspin.nims Normal file
View File

@ -0,0 +1,5 @@
switch("gc", "none")
when defined(release):
switch("checks", "off")
switch("debuginfo", "off")

4
wpspin.nimble
View File

@ -1,6 +1,6 @@
# Package # Package
version = "0.3.0" version = "0.5.1"
author = "Victor Golovanenko (drygdryg)" author = "Victor Golovanenko (drygdryg)"
description = "Full-featured WPS PIN generator" description = "Full-featured WPS PIN generator"
license = "MIT" license = "MIT"
@ -12,4 +12,4 @@ bin = @["wpspin"]
# Dependencies # Dependencies
requires "nim >= 0.20.0" requires "nim >= 0.20.0"
requires "argparse >= 0.10.1" requires "argparse >= 2.0.0"