Wie kann ich es reaslisieren, dass ich mit einem Bruteforce hack zum beispiel eine mit passwort gesicherte Word datei cracken kann. Also wie kann ich es schaffen, dass die möglichkeiten bei word ausprobiert werden?
Function canOpen(docFile as String, password As String) as Boolean
On Error Goto canOpen_Err
checkPassword := False
Documents.Open FileName:=docFile, PasswordDocument := password
checkPassword := True
canOpen_Err:
Exit Function
Ok ,viele haben damit einfach massive Probleme, deswegen...Bruteforce
public static class SIter implements Iterable<String> {
private char[] a;
/**
* three is the maximum length
*/
private int[] is = new int[3];
/**
* at least one character
*/
private int l = 1;
public SIter(char... a) {
if (a == null || a.length == 0) {
throw new IllegalArgumentException("a == null || a.length == 0");
}
this.a = a;
}
@Override
public Iterator<String> iterator() {
return new Iterator<String>() {
@Override
public boolean hasNext() {
return l <= is.length;
}
@Override
public String next() {
String s = "";
for (int i = 0; i < l; i++) {
s += a[is[i]];
}
for (int j = 0; j < is.length; j++) {
is[j]++;
if (is[j] < a.length) {
break;
}
is[j] = 0;
if (j == l - 1) {
l++;
break;
}
}
return s;
}
};
}
}
public static void main(String[] args) {
for (String s : new SIter('a', 'b', 'c', 'd')) {
System.out.println(s);
}
}
a
b
c
d
aa
ba
ca
da
ab
bb
cb
db
ac
bc
cc
dc
ad
bd
cd
dd
aaa
baa
caa
daa
aba
bba
cba
dba
aca
bca
cca
dca
ada
bda
cda
dda
aab
bab
cab
dab
abb
bbb
cbb
dbb
acb
bcb
ccb
dcb
adb
bdb
cdb
ddb
aac
bac
cac
dac
abc
bbc
cbc
dbc
acc
bcc
ccc
dcc
adc
bdc
cdc
ddc
aad
bad
cad
dad
abd
bbd
cbd
dbd
acd
bcd
ccd
dcd
add
bdd
cdd
ddd
mit einer library oder zu Fuß siehe auch den Beitrag vom @mihe7ich meine wie kann ich die asugabe in das word passwort fenster eingeben?
Ich würde fast vermuten das es einen Grund gibt, warum eine Datei Passwort geschützt ist. Aber wie gesagt, nur eine Vermutung.@Nesselbrand Kannst du mir die passwortgeschützte Datei senden - oder ist das geheim?
Ich hab aber kein WordAber zum Testen könntest Du Dir doch eine Datei selber mit einem Passwort versehen
Auch kein LibreOffice?Ich hab aber kein Word
Doch, das schon... auf der Arbeitsmaschine hätte ich Word, aber das ist naja für die Arbeit eben... ich denke, mein Chef wäre nicht begeistert, wenn ich nebenbei Verschlüsselungsmechanismen umgehen würd...Auch kein LibreOffice?
Wenn es nur darum geht: für das Passwort-Recovery von Word-Dateien gibt es fertige Programme.Ich würde fast vermuten das es einen Grund gibt, warum eine Datei Passwort geschützt ist. Aber wie gesagt, nur eine Vermutung.
(Oder könnte man das noch einfacher schreiben? )
import java.util.stream.*;
public class StringPermutations {
private static final char[] ALPHABET = { 'a', 'b', 'c', 'd', 'e', 'f' };
private static String cvt(long v, int sb) {
return (v --> sb ? cvt(v / sb, sb) : "") + ALPHABET[(int) (v % sb)];
}
public static Stream<String> combinations() {
return iterate(1L, i -> i + 1L).mapToObj(i -> cvt(i, ALPHABET.length));
}
public static void main(String[] args) {
combinations().forEach(System.out::println);
}
}
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>Zips1</groupId>
<artifactId>Zips1</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>4.1.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>4.1.1</version>
</dependency>
</dependencies>
</project>
import java.io.File;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Iterator;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import org.apache.poi.poifs.crypt.Decryptor;
import org.apache.poi.poifs.crypt.EncryptionInfo;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
public class M {
public static class SIter implements Iterable<String> {
private char[] a;
/**
* five is the maximum length
*/
private int[] is = new int[5];
/**
* at least one character
*/
private int l = 1;
public SIter(char... a) {
if (a == null || a.length == 0) {
throw new IllegalArgumentException("a == null || a.length == 0");
}
this.a = a;
}
@Override
public Iterator<String> iterator() {
return new Iterator<String>() {
@Override
public boolean hasNext() {
return l <= is.length;
}
@Override
public String next() {
String s = "";
for (int i = 0; i < l; i++) {
s += a[is[i]];
}
for (int j = 0; j < is.length; j++) {
is[j]++;
if (is[j] < a.length) {
break;
}
is[j] = 0;
if (j == l - 1) {
l++;
break;
}
}
return s;
}
};
}
}
public static void main(String[] args) throws IOException {
JFileChooser c = new JFileChooser();
c.showOpenDialog(null);
File f = c.getSelectedFile();
EncryptionInfo ei = new EncryptionInfo(new POIFSFileSystem(f));
Decryptor d = ei.getDecryptor();
String pw = null;
try {
for (String s : new SIter("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 !\"#$%&'()*+,-./:;".toCharArray())) { // beschränke das auf die tatsächlichen Zeichen
if (d.verifyPassword(s)) {
pw = s;
break;
}
}
} catch (GeneralSecurityException e) {
e.printStackTrace();
}
JOptionPane.showConfirmDialog(null, "Password: " + pw);
}
}
Den Kontrollfluss einer Methode beliebig zu verändern ist mit Streams nicht nötig, da sie selbst lazy ausgewertet werden. Der Aufrufer entscheidet in diesem Fall, ob er noch mehr Elemente haben möchte, oder nicht. Wo und warum willst du da herausspringen?Bei Streams das Problem, dass aus diesen nicht einfach heraus gesprungen werden kann.
In diesem Fall hast du Recht.long ist als Zählvariable begrenzt.
"Lesbarkeit" ist Gewöhnungssache. Ich finde dein langes for-schleifen-mit-breaks-und-if-bedingungen-und-Indexarithmetik-Monster persönlich viel unleserlicher als meine zwei Zeilen Code (der effektive Code in den Methoden cvt und combinations).nicht lesbar
Tests sollten die Schnittstelle testen und die sieht bei uns beiden gleich aus: Es entsteht ein Iterator bzw. Stream aus Strings. Auch ist der Input bei uns beiden derselbe: Ein Alphabet. Das kann man in beiden Fällen sehr gut testen. Natürlich kann man bei mir das aktuell fixe Alphabet als Parameter reinziehen. Ändert an dem Algorithmus nichts.nicht testbar
import static java.util.stream.LongStream.*;
import static org.junit.jupiter.api.Assertions.*;
import java.util.stream.*;
import org.junit.jupiter.api.Test;
public class StringPermutations {
private static String cvt(long v, char[] alphabet) {
int sb = alphabet.length;
return (v --> sb ? cvt(v / sb, alphabet) : "") + alphabet[(int) (v % sb)];
}
public static Stream<String> combinations(char[] alphabet) {
return iterate(1L, i -> i + 1L).mapToObj(i -> cvt(i, alphabet));
}
// Ein möglicher Test dazu (natürlich in einer separaten Test-Klasse):
@Test
public void testFirstStringWithLength2() {
// given
char[] ALPHABET = {'a', 'b', 'c'};
// when
// als 4. String sollte "aa" kommen
String actual = combinations(ALPHABET).skip(3).findFirst().get();
// then
assertEquals("aa", actual);
}
}
Naja er hat schon seine Schwächen; aber jedem das was er bevorzugen möchte.Nicht zuletzt ist "funktional zu denken" ein Paradigment-shift, der genauso gut funktioniert wie imperativ
Na dann ist es doch wumpe.ich habe da nähmlich nichts reingeschrieben ich