Verschlüsselt positive Zahlen ab 0. Wenn Sie Zahlen angeben, die gehorsam als 1, 2, 3 für die Benutzer-ID usw. erhöht werden, ist Round-Robin-Hacking einfach und unterstützt zufällige Zeichenfolgen und Inkremente, um Round-Robin-Angriffe aufgrund einfacher Inkremente zu verhindern. Die Motivation für diesen Fall ist die Generierung einer ID. Ein Ausführungsbeispiel ist unten gezeigt.
0 -> 052C5C223627156D7
1 -> 1572257C261D2C376
2 -> 252C1C627627952D3
3 -> 352CEC223627156D7
4 -> 452C1C627627452D3
5 -> 552C1C627627F52D3
6 -> 6512253C662D2C772
7 -> 75D2257C261D2C376
8 -> 8512253C663D2C772
9 -> 953D25C726726C1C2
10 -> A53D258726726C1C2
Wie oben erwähnt, werden die Zahlen, die nur von 0 auf 10 erhöht werden, auf diese Weise in die verschlüsselte ID konvertiert. Im Folgenden wird davon ausgegangen, dass eine 16-stellige ID mit einer hexadezimalen Zeichenfolge erstellt wird.
Konvertieren Sie die zu verschlüsselnde Zahl in eine hexadezimale Zeichenfolge und tauschen Sie die Ziffern mit dem Rest des Index der Zeichenfolge geteilt durch die Primzahl als entsprechende Ziffer aus.
n = 9999
PrimeTable = [61, 31, 53, 29, 37, 5, 23, 47, 7, 59, 43, 3, 17, 13, 19, 41, 11]
mod = n % 16 # mod = 15
mod = int(enc[0], 16)
prime = PrimeTable[mod] # prime = 41
for i in range(16):
dig = (i * prime) % 16
#Entsprechende Ziffer=> 0, 9, 2, 11, 4 ,13, 6, 15, 8, 1, 10, 3, 12, 5, 14, 7
Normalerweise beginnt die untere Position von rechts und die große Position von links, aber das Mischen der entsprechenden Ziffern vermeidet einfache Inkremente.
Als Einschränkung können Sie möglicherweise nicht dieselbe Primzahl wie die Anzahl der Ziffern auswählen. Wenn Sie eine 17-stellige ID verwenden und versuchen möchten, die Anzahl der Ziffern mit 17 zu mischen, ist alles die 0. Ziffer.
>dig = (i * prime) % 16
↓
>dig = (i * 17) % 17
Unabhängig vom Wert von i kann dig nur 0 sein
Selbst wenn Sie die Ziffern mischen, können Sie die ID bis zu einem gewissen Grad schätzen, wenn die Nummer jeder Ziffer bei 0 beginnt und mit F endet. Ersetzen Sie also 0 bis F durch das Ergebnis der entsprechenden Tabelle. Erstellen Sie eine Tabelle wie die folgende und lassen Sie sie jeder Ziffer entsprechen. Ich dachte, es wäre möglich, Dinge wie das dynamische Generieren einer Tabelle zu automatisieren, aber ich konnte mir keine weitere Verarbeitung vorstellen, also implementierte ich sie durch Einbetten der Tabelle.
digitsTable = [
[5, 3, 15, 14, 11, 7, 6, 2, 12, 8, 10, 13, 4, 1, 9, 0],
[6, 5, 13, 7, 15, 11, 14, 12, 0, 8, 2, 9, 3, 4, 1, 10],
[7, 0, 11, 15, 2, 13, 12, 6, 4, 10, 9, 5, 1, 3, 14, 8],
[3, 6, 13, 7, 5, 10, 14, 0, 1, 9, 15, 4, 11, 8, 2, 12],
[12, 10, 2, 3, 4, 5, 6, 15, 7, 11, 13, 0, 14, 9, 1, 8],
[2, 10, 13, 14, 0, 1, 12, 6, 3, 15, 11, 5, 9, 7, 8, 4],
[13, 8, 9, 14, 0, 15, 1, 3, 2, 11, 5, 12, 7, 4, 10, 6],
[1, 10, 15, 7, 14, 6, 12, 11, 2, 8, 4, 5, 13, 0, 9, 3],
[6, 4, 7, 1, 12, 8, 10, 0, 15, 14, 9, 13, 5, 11, 3, 2],
[2, 14, 13, 15, 6, 11, 10, 7, 3, 8, 1, 4, 5, 0, 9, 12],
[12, 4, 2, 5, 10, 3, 0, 11, 8, 14, 13, 1, 7, 6, 15, 9],
[7, 1, 14, 5, 0, 2, 9, 12, 8, 6, 4, 3, 11, 10, 15, 13],
[5, 8, 4, 2, 11, 10, 7, 14, 3, 0, 12, 6, 9, 13, 1, 15],
[2, 4, 14, 13, 15, 10, 7, 6, 9, 11, 1, 0, 12, 3, 8, 5],
[2, 14, 9, 11, 5, 3, 6, 1, 12, 13, 8, 4, 15, 7, 0, 10],
[5, 7, 9, 14, 4, 15, 2, 13, 3, 12, 8, 1, 10, 6, 11, 0],
]
digitsTable = [
[5, 3, 15, 14, 11, 7, 6, 2, 12, 8, 10, 13, 4, 1, 9, 0],
[6, 5, 13, 7, 15, 11, 14, 12, 0, 8, 2, 9, 3, 4, 1, 10],
[7, 0, 11, 15, 2, 13, 12, 6, 4, 10, 9, 5, 1, 3, 14, 8],
[3, 6, 13, 7, 5, 10, 14, 0, 1, 9, 15, 4, 11, 8, 2, 12],
[12, 10, 2, 3, 4, 5, 6, 15, 7, 11, 13, 0, 14, 9, 1, 8],
[2, 10, 13, 14, 0, 1, 12, 6, 3, 15, 11, 5, 9, 7, 8, 4],
[13, 8, 9, 14, 0, 15, 1, 3, 2, 11, 5, 12, 7, 4, 10, 6],
[1, 10, 15, 7, 14, 6, 12, 11, 2, 8, 4, 5, 13, 0, 9, 3],
[6, 4, 7, 1, 12, 8, 10, 0, 15, 14, 9, 13, 5, 11, 3, 2],
[2, 14, 13, 15, 6, 11, 10, 7, 3, 8, 1, 4, 5, 0, 9, 12],
[12, 4, 2, 5, 10, 3, 0, 11, 8, 14, 13, 1, 7, 6, 15, 9],
[7, 1, 14, 5, 0, 2, 9, 12, 8, 6, 4, 3, 11, 10, 15, 13],
[5, 8, 4, 2, 11, 10, 7, 14, 3, 0, 12, 6, 9, 13, 1, 15],
[2, 4, 14, 13, 15, 10, 7, 6, 9, 11, 1, 0, 12, 3, 8, 5],
[2, 14, 9, 11, 5, 3, 6, 1, 12, 13, 8, 4, 15, 7, 0, 10],
[5, 7, 9, 14, 4, 15, 2, 13, 3, 12, 8, 1, 10, 6, 11, 0],
]
#Erstellen Sie eine umgekehrte Tabelle zur Entschlüsselung
digitsReverseTable = []
for tbl in digitsTable:
a = [0] * 16
for i, v in enumerate(tbl):
a[v] = i
digitsReverseTable.append(a)
PrimeTable = [61, 31, 53, 29, 37, 5, 23, 47, 7, 59, 43, 3, 17, 13, 19, 41, 11]
def encodeNumber(n):
hexStr = "00000000000000000000" + "{:X}".format(n)
hexStr = hexStr[-16:]
mod = n % 16
prime = PrimeTable[mod]
enc = [""] * 16
for i in range(16):
c = hexStr[i]
dig = (i * prime) % 16
idx = int(c, 16)
m = digitsTable[i][idx]
enc[dig] = "{:X}".format(m)
#Lassen Sie den Mod in der ID zur Entschlüsselung
return "{:X}".format(mod) + "".join(enc)
def decodeNumber(enc):
mod = int(enc[0], 16)
prime = PrimeTable[mod]
enc = enc[1:]
numArr = [0] * 16
for i in range(16):
dig = (i * prime) % 16
ridx = int(enc[dig], 16)
m = digitsReverseTable[i][ridx]
numArr[i] = m
numArr = list(reversed(numArr))
n = 0
for i in range(16):
n += numArr[i] * 16 ** i
return n
def main():
for i in range(0, 100):
enc = encodeNumber(i)
print(i, enc, decodeNumber(enc))
if __name__ == "__main__":
main()
# python encode_counter.py
0 052C5C223627156D7 0
1 1572257C261D2C376 1
2 252C1C627627952D3 2
3 352CEC223627156D7 3
4 452C1C627627452D3 4
5 552C1C627627F52D3 5
6 6512253C662D2C772 6
7 75D2257C261D2C376 7
8 8512253C663D2C772 8
9 953D25C726726C1C2 9
10 A53D258726726C1C2 10
11 B57D651726322C1C2 11
12 C5673C2D162C7522A 12
13 D52C6C223627156D7 13
Unterwegs weggelassen
89 953D25C726736C1C2 89
90 A53D258726736C1C2 90
91 B57D651726332C1C2 91
92 C5673C2D162C7523A 92
93 D52C6C233627156D7 93
94 E57D651726332CBC2 94
95 F5277C2D066C35231 95
96 052C5C263627156D7 96
97 1576257C261D2C376 97
98 252C1C667627952D3 98
99 352CEC263627156D7 99
Anstatt es so zu verwenden, wie es ist, ist es meiner Meinung nach besser, alle 2 bis 4 Zeichen zufällig eine Dummy-Zeichenfolge einzufügen. Vermeiden Sie natürlich die Verwendung der so beschriebenen Beispielquelle.
Wenn Sie im Voraus eine ID eingeben, können Sie die Verwendung komplizierter Logik wie in diesem Fall vermeiden. Wenn Sie in dem System, das Sie erstellen möchten, von einer Obergrenze wie "10.000 ist ausreichend" ausgehen können, erstellen und verwenden Sie beim Erstellen und Verwenden einer mit 0 bis 9999 verknüpften Tabelle, indem Sie im Voraus 10.000 IDs mit einer zufälligen Zeichenfolge ausgeben Verwenden Sie die entsprechende Tabelle. Vergessen Sie nicht, eine Überprüfung durchzuführen, um sicherzustellen, dass Ihre ID eindeutig ist.
Diese Art der Verarbeitung scheint sehr gefragt zu sein, also habe ich es gemacht, während ich dachte, dass es in der vorhandenen Bibliothek zu sein scheint, aber ich wusste nicht, was ich dieses Konzept sagen sollte, und ich konnte mir kein Suchwort vorstellen, also habe ich es selbst gemacht und kommentiert, ob es eine Bibliothek gibt, die dasselbe tut Bitte sag mir. das ist alles.