Parallel brute force: Difference between revisions

=={{header|Ada}}==

{{libheader|CryptAda}}

 

with CryptAda.Digests.Message_Digests.SHA_256;

Work := new Worker (First => C);

end loop;

 

=={{header|BaCon}}==

PRAGMA LDFLAGS -lcrypto

 

LOCAL buffer[32], passwd[5] TYPE unsigned char

LOCAL result TYPE unsigned char*

 

 

WHILE TRUE

NEXT

NEXT

{{out}}

<pre>

=={{header|C}}==

{{trans|C#}}

// $ export OMP_NUM_THREADS=4

// $ ./parabrutfor

 

return 0;

{{out}}

<pre>apple => 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b

=={{header|C sharp|C#}}==

 

using System.Linq;

using System.Text;

return true;

}

 

{{out}}

=={{header|C++}}==

{{libheader|OpenSSL}}

#include <cstdio>

#include <cstring>

#include <string>

#include <vector>

#include <openssl/sha.h>

 

}

bool parse(const std::string& hash) {

std::cerr << "Invalid SHA-256 hash\n";

return false;

password_finder(int);

void find_passwords(const std::vector<std::string>&);

private:

int length;

--count;

std::ostringstream out;

std::cout << out.str();

break;

for (int i = 0; i < n; ++i) {

char c = 'a' + i;

}

}

pf.find_passwords(hashes);

return 0;

 

{{out}}

=={{header|Clojure}}==

{{libheader|clojure.math.combinatorics}}

(:require [clojure.math.combinatorics :refer [selections]]) ;; https://github.com/clojure/math.combinatorics

(:import [java.util Arrays]

(some (partial check-candidate target-bytes sha256)

(selections space 5)))))))

{{out}}

<pre>Answer found for: 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b => apple

{{libheader|lparallel}}

{{libheader|ironclad}}

(:use #:cl

#:lparallel))

(end-kernel))))

(dolist (r results)

{{out}}

<pre>apple: 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b

mmmmm: 74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f

zyzzx: 1115dd800feaacefdf481f1f9070374a2a81e27880f187396db67958b207cbad</pre>

 

=={{header|D}}==

There is at least one more method not shown for doing the task in parallel, which uses the std.concurrency module instead.

import std.parallelism;

import std.range;

 

return true;

 

{{out}}

mmmmm <=> 74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f

zyzzx <=> 1115dd80feaacefdf481f1f9070374a2a81e27880f187396db67958b27cbad</pre>

 

=={{header|F_Sharp|F#}}==

(*

Nigel Galloway February 21st., 2017

 

for r in n1.Result@n2.Result@n3.Result@n4.Result@n5.Result@n6.Result@n7.Result@n8.Result do printfn "%s" r

{{out}}

<pre>

apple

zyzzx

</pre>

 

This solution runs 26 goroutines, one for each possible password first letter.

Goroutines run in parallel on a multicore system.

 

import (

return

}

{{out}}

<pre>

<li>monad-par</li>

<li>bytestring</li>

<li>split</li>

</ul>

<br/>

import Control.Monad.Par (runPar, get, spawnP)

import Data.List.Split (chunksOf)

import Text.Printf (printf)

 

[ "3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b"

, "74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f"

 

where

findMatch s accum

| otherwise = accum

where

 

main :: IO ()

{{out}}

74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f -> mmmmm

1115dd800feaacefdf481f1f9070374a2a81e27880f187396db67958b207cbad -> zyzzx

</pre>

 

=={{header|Java}}==

This implementation runs 3 threads (one per hash to crack), and short-stops when a match for a hash is found.

 

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

 

 

{{out}}<pre>Hash 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b has the following match : apple

Hash 74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f has the following match : mmmmm

===Faster Alternative Version===

Combines ideas from the C++ solution and the above Java version. Execution time is about 1.6 seconds on my system (3.2 GHz Quad-Core Intel Core i5, macOS 10.15.3).

import java.security.*;

import java.util.*;

private byte[][] digests;

private AtomicInteger count = new AtomicInteger();

{{out}}

<pre>

 

=={{header|Julia}}==

 

@everywhere function bruteForceRange(startSerial, numberToDo)

@everywhere perThread = div(26^5, Sys.CPU_CORES)

pmap(x -> bruteForceRange(x * perThread, perThread), 0:Sys.CPU_CORES-1)

{{out}}<pre>From worker 2: apple --> 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b

From worker 3: zyzzx --> 1115dd800feaacefdf481f1f9070374a2a81e27880f187396db67958b207cbad

=={{header|Kotlin}}==

{{trans|C#}}

 

import java.security.MessageDigest

}

}

 

{{out}}

</pre>

 

 

If[MemberQ[{16^^1115dd800feaacefdf481f1f9070374a2a81e27880f187396db67958b207cbad,

16^^3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b,

ParallelDo[

testPassword[StringJoin[a, b, c, d, e]],

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM SHA256 IMPORT SHA256,Create,Destroy,HashBytes,Finalize,GetHash;

WriteLn;

ReadChar

{{out}}

<pre>apple 3A7BD3E2360A3D29EEA436FCFB7E44C735D117C42D1C1835420B6B9942DD4F1B

zyzzx 1115DD800FEAACEFDF481F1F9070374A2A81E27880F187396DB67958B207CBAD

Done</pre>

 

=={{header|Perl}}==

Uses threads library to do naive search using 26 threads ("aaaaa" .. "azzzz", "baaaa" .. "bzzzz", etc.). No effort is made to early exit.

use threads;

use threads::shared;

$s++;

}

{{out}}

<pre>

=={{header|Phix}}==

Each thread processes one start letter at a time, until they are all done.

{{out}} (with nthreads loop from 1 to 4, and for that case CPU use in Task Manager shows a very clear step pattern.)

<pre>

completed with 4 threads in 12.7s

</pre>

 

=={{header|Python}}==

 

from hashlib import sha256

 

 

 

def main():

with multiprocessing.Pool() as p:

 

if __name__ == "__main__":

 

{{out}}

the single threaded version.

 

(require racket/place

racket/list

.

#"\21\25\335\200\17\352\254\357\337H\37\37\220p7J*\201\342x\200\361\2079m\266yX\262\a\313\255"))

 

{{out}}

(formerly Perl 6)

This solution can be changed from parallel to serial by removing the <code>.race</code> method.

constant @alpha2 = [X~] <a m p y z> xx 2;

constant @alpha3 = [X~] <e l m p x z> xx 3;

}

 

{{Out}}

<pre>apple => 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b

 

Testers can adjust the run speed by replacing the @alpha constants with one of the below:

# True to actual RC task, but slowest

constant @alpha2 = 'aa' .. 'zz';

constant @alpha2 = [X~] <a m p y z> xx 2;

constant @alpha3 = [X~] <e l m p x z> xx 3;

 

=={{header|Rust}}==

In this solution the number of threads is the number of logical processors on the machine. `distribute_work()` distributes the work more or less equally between the threads.

 

// rust-crypto = "0.2.36"

// num_cpus = "1.7.0"

}

result.clone()

 

{{out}}

This example converts the collection of candidate strings into a ParVector as soon as possible, speeding up both the final step to generating the candidates and the search.

 

 

import scala.collection.parallel.immutable.ParVector

digester.digest(str.getBytes("UTF-8")).map("%02x".format(_)).mkString

}

 

An unfortunate side-effect of jumping straight into a ParVector, though, is that the entire list of candidate strings must be computed before attempting to find a match. This means that even modestly large charsets and/or strings can make the memory usage and runtime blow up.

Notice that def is used in place of val when working with the list of candidates. This is because val holds onto the head, which means it would fill up memory over time with the backlog of candidates already checked. Using def lets the program discard candidates after they are checked.

 

 

import scala.annotation.tailrec

digester.digest(str.getBytes("UTF-8")).map("%02x".format(_)).mkString

}

 

As a final example, we can clean this code up with some method chaining and currying to get this:

 

 

import scala.collection.parallel.immutable.ParVector

.map(_.to(ParVector).find(str => getHash(str) == hash)) //Convert each chunk into a ParVector and search it

.collectFirst{case Some(res) => res} //Get the first hit if one is found

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

 

var letters = @('a'..'z')

var phrase = invert_sha256(t)

say "#{t} : #{phrase}"

{{out}}

<pre>

74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f : mmmmm

</pre>

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>mmmmm => 74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f

apple => 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b

zyzzx => 1115dd800feaacefdf481f1f9070374a2a81e27880f187396db67958b207cbad</pre>

 

=={{header|zkl}}==

Uses the message hashing extension library (DLL).

{{trans|==C sharp|C#}}

var [const] gotEm=Atomic.Int(); // global signal for all threads

 

}

}

"74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f",

"1115dd800feaacefdf481f1f9070374a2a81e27880f187396db67958b207cbad");

s+=n;

}

<pre>

mmmmm --> 74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f