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

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>

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

=={{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}}

{{libheader| System.Threading}}

{{libheader| DCPsha256}}[[https://github.com/StephenGenusa/DCPCrypt]]

program Parallel_Brute_Force;

Writeln('Enter to exit');

readln;

=={{header|Erlang}}==

There are a total of 8 tasks, each handling a different set of prefixes (abc, def, ghi, jkl, mno, pqr, stuv, wxyz)

#! /usr/bin/escript

-mode(compile).

[io:format("~s: ~s~n", Result) || Result <- Results].

{{Out}}

<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>

{{trans|Visual_Basic_.NET}}

{{trans|BaCon}}

#Macro Ch (x, y, z)

(((x) And (y)) Xor ((Not (x)) And z))

PrintCode(i)

Next i

=={{header|Frink}}==

This does not use any parallel processing but just demonstrates Frink's built-in password hashing.

"3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b",

"74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f"]

if hashes.contains[hash]

println["$str: $hash"]

{{out}}

<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>

Compile with "-O2 -threaded"<br/>

7.391s elapsed on a 2.5 GHz Dual-Core Intel Core i7 Macbook Pro.

import Crypto.Hash (hashWith, SHA256 (..), Digest)

import Control.Monad (replicateM, join, (>=>))

setNumCapabilities cpus

printf "Using %d cores\n" cpus

{{out}}

<pre>brute

<p>Here all the possible test strings are batched as a stream that is fed to worker threads via a single read channel (batchChan). Each worker thread listens to the read channel (batchChan) and will write to the write channel (resultChan) when it finds a match. The worker threads loop indefinitely returning to read the next message on the read channel (batchChan). The main thread listens to the write channel (resultChan) and terminates once all three messages have been received.</p>

import Control.Concurrent.Chan (Chan, newChan, readChan, writeList2Chan)

import Control.Monad (replicateM, replicateM_, forever)

replicateM_ wCount (forkIO $ searchWorker batchChan resultChan)

writeList2Chan batchChan chunks

{{out}}

<pre>brute2

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}}

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

Using a thread for each starting character.

Note that the program must be compiled with option --threads:on.

import nimcrypto

spawn findHashes(a)

{{out}}

=={{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.

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">sha256</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">VM</span><span style="color: #0000FF;">\</span><span style="color: #000000;">pThreadN</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span> <span style="color: #000080;font-style:italic;">-- (shd not be rqd on 0.8.1+)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"completed with %d threads in %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">nthreads</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

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

<pre>

=={{header|PureBasic}}==

NewList sha256fp.s()

EndIf

End

{{out}}

<pre>apple => 3a7bd3e2360a3d29eea436fcfb7e44c735d117c42d1c1835420b6b9942dd4f1b

=={{header|Python}}==

from hashlib import sha256

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>

=={{header|Swift}}==

import CryptoKit

}

}

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

{{trans|C#}}

Module Module1

End Sub

{{out}}

<pre>mmmmm => 74e1bb62f8dabb8125a58852b63bdf6eaef667cb56ac7f7cdba6d7305c50a22f

Currently, parallel calculations are impossible in Wren-cli. However, if Wren is being embedded, it might be possible for a suitable host to run several Wren VM's in parallel and divide a task up between them to improve execution time.

var hashes = [

var fib = Fiber.new(findHash)

fib.call(97+i)

{{out}}

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