maccaroni
BAN USER- 0of 0 votes
AnswersBelow is the hash :
- maccaroni in United States
c31843b739e61ec7bf5f63da93d97d0321f42f0304750c41ae88a3b04727ba21f5c7061e7517101f3b8f2fa53d3a32960c03e3b78112619b2674802429d831fcdb38fdff909bdcb6a2da09a462e35671c310e4954d1578a0194cf86b6e4b2550a58893d756c0d557451c487546b7a908377d5cc436daa6bd0cebbd8a2593db7ccc536aab131d8ca8c4c5daf505190d6e61a0c80b65d337e839c4c77c5a7f90daaf5aed8aff7d43876194d64a289cf42aedd977889120178500f4ef48aa3cdae78b1a4383d8f4f136f02c1d2d122f8819d8a2c66de0240ce2416ba43b0346de0450684f874fdb5d34b698e8a93ee45e15e8994c361f387a9fe94107b2d11f743cc34843d9031a7a0c01976ecf1f88056a6fa1b40744a88a37ee95fc66058370def144c686d692f012b07f56c497955a8fc40a51652240928e3c899aca8791a8e5f345f65745cfbec16f0446bafaa3e0593ab2d69e02b2562029178779e835cc933c99d289cc96b51f63a0c8abb01bc9df2659480fbb2f17f3b0817c807d222abbd58d1c60037ec5e35c06f2080a3b593928be4af515573024bdf5603f9696de81af8b065f6e2976a2efaa097d6613431c162c7acb00f7892acb3a2ffef15701bd
First, A series of string prefixes is generated with lengths increasing by 2. For example, if our secret word was "abcxy@hoho.com", we would generate:
ab abcx abcxy@ abcxy@ho ... ...... abcxy@hoho.com
Then, for every prefix s, following hash H is computed: md5(md5(e) + s + md5(s)) [where + is the string concatenation operator and e is "xxxxx@hehu.xxx.edu"].
Finally, all hash strings H are concatenated to form the long hash above....
For example, for abcxy@hoho.com, - the hash would be computed as
md5(md5('xxxxx@hehu.xxx.edu') + 'ab' + md5('ab')) +
md5(md5('xxxxx@hehu.xxx.edu') + 'abcx' + md5('abcx')) +
md5(md5('xxxxx@hehu.xxx.edu') + 'abcxy@' + md5('abcxy@')) +
...
For the sake of simplicity, you can assume that secret word only contains alphanumeric characters and these 4 characters: _ . @ +
and using e= xxxxx@hehu.xxx.edu, the hash is generated.
and we have to find out that secret word (from the hash).
These are the details I have researched:
Hash from MD5 is always 128 bits/16 bytes/32 ascii characters long
Collision Attack
Birthday Attack
Any Hidden paterns in the given hash
I am looking for a direction here. The given hash is exactly 896 letters long. Any ideas or redirects are much appreciated. Thanks.| Report Duplicate | Flag | PURGE
Microsoft Scientific Officer Algorithm
package com.company;
public class Main {
public static void main(String args[]) {
Node head = new Node(1);
LinkedList originalLinkedList = new LinkedList(head);
originalLinkedList.addNode(new Node(2));
originalLinkedList.addNode(new Node(3));
originalLinkedList.addNode(new Node(4));
originalLinkedList.addNode(new Node(5));
originalLinkedList.addNode(new Node(6));
originalLinkedList.addNode(new Node(7));
originalLinkedList.addNode(new Node(8));
System.out.println("----BEFORE----");
originalLinkedList.printNodes();
System.out.println("\n"+"----AFTER----");
originalLinkedList.swap(3);
}
static class LinkedList {
public Node head;
public Node tail;
public int length = 1;
public LinkedList(Node head) {
this.head = head;
this.tail = head;
}
public void addNode(Node node) {
length++;
tail.next = node;
tail = node;
}
public void printNodes() {
System.out.println("\n");
Node tempHead = head;
while (tempHead.next != null) {
System.out.print(tempHead.value + " ");
tempHead = tempHead.next;
}
System.out.print(tempHead.value);
}
public int getNodeValueAt(int index) {
if (index == 1) {
return head.value;
}
if (index == length) {
return tail.value;
}
Node tempHead = head.next;
int ctr = 2;
while (tempHead.next != null) {
if (ctr == index) {
return tempHead.value;
} else {
tempHead = tempHead.next;
ctr++;
}
}
return -1;
}
public Node getNodeAt(int index) {
if (index == 1) {
return head;
}
if (index == length) {
return tail;
}
Node tempHead = head.next;
int ctr = 2;
while (tempHead.next != null) {
if (ctr == index) {
return tempHead;
} else {
tempHead = tempHead.next;
ctr++;
}
}
return null;
}
public void swap(int pos) {
final int nodePosFromEnd = length - (pos - 1);
final int firstNodeValue = getNodeValueAt(nodePosFromEnd);
final int secondNodeValue = getNodeValueAt(pos);
getNodeAt(pos).value = firstNodeValue;
getNodeAt(nodePosFromEnd).value = secondNodeValue;
printNodes();
}
}
static class Node {
public Node next;
public int value;
public Node(int value) {
this.value = value;
this.next = null;
}
public Node(int value, Node next) {
this.value = value;
this.next = next;
}
public void setNext(Node next) {
this.next = next;
}
public void setValue(int value) {
this.value = value;
}
}
}
package com.company;
public class Main {
public static void main(String args[]) {
LLNode head = new LLNode(1);
LinkedList originalLinkedList = new LinkedList(head);
originalLinkedList.addNode(new LLNode(2));
originalLinkedList.addNode(new LLNode(3));
originalLinkedList.addNode(new LLNode(4));
originalLinkedList.addNode(new LLNode(5));
originalLinkedList.addNode(new LLNode(6));
originalLinkedList.addNode(new LLNode(7));
originalLinkedList.addNode(new LLNode(8));
originalLinkedList.addNode(new LLNode(9));
originalLinkedList.addNode(new LLNode(10));
final int headValue = originalLinkedList.head.value;
final int secondValue = originalLinkedList.tail.value;
LinkedList modified = new LinkedList(new LLNode(headValue));
modified.addNode(new LLNode(secondValue));
int currentIndex = 2;
int endIndex = originalLinkedList.length / 2;
int ctr = 0;
while (currentIndex <= endIndex) {
int currValue = originalLinkedList.getNodeAt(currentIndex);
ctr++;
int nextValue = originalLinkedList.getNodeAt(originalLinkedList.length - ctr);
modified.addNode(new LLNode(currValue));
modified.addNode(new LLNode(nextValue));
currentIndex++;
}
modified.printNodes();
}
static class LinkedList {
public LLNode head;
public LLNode tail;
public int length = 1;
public LinkedList(LLNode head) {
this.head = head;
this.tail = head;
}
public void addNode(LLNode node) {
length++;
tail.next = node;
tail = node;
}
public void printNodes() {
LLNode tempHead = head;
while (tempHead.next != null) {
System.out.print(tempHead.value + " ");
tempHead = tempHead.next;
}
System.out.print(tempHead.value);
}
public int getNodeAt(int index) {
if (index == 1) {
return head.value;
}
if (index == length) {
return tail.value;
}
LLNode tempHead = head.next;
int ctr = 2;
while (tempHead.next != null) {
if (ctr == index) {
return tempHead.value;
} else {
tempHead = tempHead.next;
ctr++;
}
}
return -1;
}
}
static class LLNode {
public LLNode next;
public int value;
public LLNode(int value) {
this.value = value;
this.next = null;
}
public LLNode(int value, LLNode next) {
this.value = value;
this.next = next;
}
}
}
- maccaroni August 15, 2016
private static int[] getPath(int i, int j, int[] currPath) {
- maccaroni August 16, 2016if (i <= 2 && j <= 2) {
final int currValue = matrix[i][j];
final int[] currTotalPath = mergeArrs(currPath, new int[]{currValue});
if (i == 2 && j == 2) {
return currTotalPath;
}
int arrRight[] = getPath(i, j + 1, currTotalPath);
int arrDown[] = getPath(i + 1, j, currTotalPath);
int arrDiag[] = getPath(i + 1, j + 1, currTotalPath);
return getMin(arrRight, arrDown, arrDiag);
} else {
return mergeArrs(currPath, new int[]{-1});
}
}