Java-Fehler: Bitweise Operatoren vs. Boolesche Operatoren
Java-Fehler: Bitweise Operatoren vs. Boolesche Operatoren
> „Java Gotcha“: ein häufiger Fehler, der leicht versehentlich implementiert werden kann.
Ein recht einfacher Java-Trick, in den man versehentlich tappen kann, ist die Verwendung eines Bit-Operators anstelle eines booleschen Vergleichsoperators.
Por ejemplo, un simple error de escritura puede resultar en escribir «&» cuando realmente querías escribir «&&».
Eine gängige Heuristik, die wir beim Überprüfen des Codes lernen, lautet:
> „&“ oder „|“ in einer bedingten Anweisung sind wahrscheinlich nicht beabsichtigt.
In diesem Blogbeitrag werden wir die Heuristik untersuchen und Wege aufzeigen, wie wir dieses Codierungsproblem erkennen und beheben können.
¿Cuál es el problema? Las operaciones bit a bit funcionan bien con los valores booleanos
Die Verwendung von Bit-Operatoren mit Booleschen Werten ist vollkommen zulässig, sodass Java keinen Syntaxfehler meldet.
Wenn wir einen JUnit-Test erstellen, um eine Wahrheitstabelle sowohl für Bitwise OR (|) als auch für Bitwise AND (&) zu untersuchen, sehen wir, dass die Ausgaben des Bitwise-Operators mit der Wahrheitstabelle übereinstimmen. Angesichts dessen könnten wir denken, dass die Verwendung von Bitwise-Operatoren kein Problem darstellt.
Y Tabelle der Wahrheit
@Test
void BitwiseOperatorsAndTruthTable () {
Assertions.assertEquals (verdadero, verdadero y verdadero);
Assertions.assertEquals (falso, verdadero y falso);
Assertions.assertEquals (falso, falso y verdadero);
Assertions.assertEquals (falso, falso y falso);
}
Der Test ist bestanden, dies ist vollkommen gültiges Java.
O Tabelle der Wahrheit
@Test
anular BitwiseOperatorSorTruthTable () {
Assertions.assertEquals (verdadero, verdadero | verdadero);
Assertions.assertEquals (verdadero, verdadero | falso);
Assertions.assertEquals (verdadero, falso | verdadero);
Assertions.assertEquals (falso, falso | falso);
}
Dieser Test ist auch bestanden, warum bevorzugen wir „&&“ und „||“?
Die Bilder der Wahrheitstabelle wurden mit dem Werkzeug „Wahrheitstabelle“ von web.standfor.eduerstellt.
Problem: Kurzschlussbetrieb
Das eigentliche Problem ist der Unterschied im Verhalten zwischen bitweisen Operatoren (&, |) und booleschen Operatoren (&&, ||).
Ein Boolescher Operator ist ein Kurzschlussoperator und wertet nur das Nötigste aus.
zum Beispiel
si (args! = nulo & args.length () > 23) {
System.out.println (argumentos);
}
Im obigen Code werden beide booleschen Bedingungen ausgewertet, da der Bitweise-Operator verwendet wurde:
- Argumente! = null
- args.length () > 23
Dies macht meinen Code anfällig für eine NullPointerException, wenn args null ist, da wir immer die Überprüfung von args.length durchführen, selbst wenn args null ist, da beide booleschen Bedingungen ausgewertet werden müssen.
Bewertung von Kurzschlüssen bei booleschen Operatoren
Wenn man ein && verwendet, z. B.
si (args! = nulo && args.length () > 23) {
System.out.println (argumentos);
}
Sobald wir wissen, dass es sich um ein Argument handelt! = null wird als falsch ausgewertet, die Auswertung des Bedingungsausdrucks wird angehalten.
Wir müssen die rechte Seite nicht bewerten.
Unabhängig vom Ergebnis der Bedingung auf der rechten Seite ist der Endwert des booleschen Ausdrucks falsch.
Aber das würde im Produktionscode niemals passieren.
Dies ist ein Fehler, der leicht zu begehen ist und von statischen Analysewerkzeugen nicht immer erkannt wird.
Ich habe den folgenden Google Dork verwendet, um zu sehen, ob ich ein öffentliches Beispiel für dieses Muster finden konnte:
Dateityp: Java, wenn „! = null &”
Diese Suche ergab einen Android-Code im RootWindowContainer
isDocument = intent! = null & intent.isDocument ()
Dies ist die Art von Code, die eine Codeüberprüfung bestehen kann, da wir häufig Bit-Operatoren in Zuweisungsanweisungen verwenden, um Werte zu maskieren. In diesem Fall ist das Ergebnis jedoch dasselbe wie im vorherigen Beispiel mit der if-Anweisung. Wenn die Absicht jemals null ist, wird eine NullPointerException ausgelöst.
Sehr oft kommen wir mit dieser Konstruktion durch, weil wir häufig defensiv programmieren und redundanten Code schreiben. Die Überprüfung „¡El cheque para! = null“ kann in den meisten Anwendungsfällen redundant sein.
Es handelt sich um einen Fehler, den die Programmierer im Produktionscode gemacht haben.
Ich weiß nicht, wie aktuell die Suchergebnisse sind, aber als ich die Suche durchgeführt habe, wurden Ergebnisse mit dem Code von Google, Amazon, Apache ... und mir angezeigt.
Ein kürzlich eingereichter Extraktionsantrag in einem meiner Open-Source-Projekte diente genau dazu, diesen Fehler zu beheben.
si (escriba! =nulo y escribe.trim () .length () >0) {
Aceptar MediaTypeDefinitionsList.add (type.trim ());
}
Wie man dies findet
Als ich meinen Beispielcode in einigen statischen Analysatoren überprüft habe, hat keiner von ihnen diesen versteckten Selbstzerstörungscode erkannt.
Als Team von Secure Code Warrior haben wir ein Sensei einfaches Sensei erstellt und überprüft, das diese Frage beantworten könnte.
Da Bitwise-Operatoren vollkommen gültig sind und häufig in Zuweisungen verwendet werden, konzentrieren wir uns auf den Anwendungsfall von if-Anweisungen und die Verwendung von Bitwise &, um den problematischen Code zu finden.
buscar:
expresión:
Cualquiera de:
- en:
condición: {}
valor:
Sensible a mayúsculas y minúsculas: falso
coincidencias: «.* & . *»
Dies verwendet einen regulären Ausdruck, um mit „&” übereinzustimmen, wenn dieser als Bedingungsausdruck verwendet wird, beispielsweise in einer if-Anweisung.
Um das Problem zu beheben, haben wir uns erneut auf reguläre Ausdrücke verlassen. Dieses Mal haben wir die sed-Funktion von QuickFix verwendet, um das & im Ausdruck global durch && zu ersetzen.
Correcciones disponibles:
- nombre: «Reemplazar el operador AND bit a bit por el operador AND lógico»
acciones:
- reescribir:
a: «{{#sed}} s/&/&&/g, {{{.}}} {{/sed}}»
Endnoten
Dies deckt den häufigsten Missbrauch eines Bit-Operators ab, d. h. wenn eigentlich ein Boolescher Operator verwendet werden sollte.
Es gibt noch andere Situationen, in denen dies auftreten könnte, beispielsweise bei einer Aufgabe, aber beim Schreiben von Rezepten müssen wir versuchen, die Identifizierung von Fehlalarmen zu vermeiden, da die Rezepte sonst ignoriert oder deaktiviert werden. Wir erstellen Rezepte, die den häufigsten Vorkommnissen entsprechen. Im Zuge Sensei werden wir der Suchfunktion möglicherweise zusätzliche Spezifität hinzufügen, um mehr übereinstimmende Bedingungen abzudecken.
In seiner aktuellen Form würde dieses Rezept viele der aktuellen Anwendungsfälle identifizieren, vor allem den, der in meinem Projekt beschrieben wurde.
HINWEIS: Einige wenige Code-Krieger haben zu diesem Beispiel und der Überarbeitung der Rezepte beigetragen: Charlie Eriksen, Matthieu Calie, Robin Claerhaut, Brysen Ackx, Nathan Desmet und Downey Robersscheuten. Vielen Dank für eure Hilfe.
---
Sie können Sensei IntelliJ unter „Einstellungen\Plugins” (Mac) oder „Konfiguration\Plugins” (Windows) installieren und anschließend nach senseisicherer Code senseisuchen.
Wir haben viele Quellcodes und Rezepte für diese Blogeinträge (einschließlich dieses) im Repositorysensei des GitHub-Kontos von Secure Code Warrior.
https://github.com/securecodewarrior/sensei-blog-examples
Weitere Informationen über Sensei
In diesem Blogbeitrag analysieren wir einen häufigen Fehler bei der Programmierung in Java (die Verwendung eines Bit-Operators anstelle eines bedingten Operators), den Fehler, der unseren Code anfällig macht, und wie wir Sensei einsetzen können, Sensei das Problem zu beheben und zu erkennen.
Alan Richardson verfügt über mehr als zwanzig Jahre Berufserfahrung in der IT-Branche. Er arbeitete als Entwickler und auf jeder Ebene der Testhierarchie, vom Tester bis hin zum Head of Testing. Als Head of Developer Relations bei Secure Code Warrior arbeitet er direkt mit Teams zusammen, um die Entwicklung von hochwertigem, sicherem Code zu verbessern. Alan ist der Autor von vier Büchern, darunter "Dear Evil Tester" und "Java For Testers". Alan hat auch Online-Schulungen courses erstellt, um Menschen beim Erlernen von technischen Web-Tests und Selenium WebDriver mit Java zu helfen. Alan veröffentlicht seine Schriften und Schulungsvideos auf SeleniumSimplified.com, EvilTester.com, JavaForTesters.com und CompendiumDev.co.uk.
Secure Code Warrior hier, um Ihrem Unternehmen dabei zu helfen, den Code während des gesamten Lebenszyklus der Softwareentwicklung zu schützen und eine Kultur zu schaffen, in der Cybersicherheit oberste Priorität hat. Ganz gleich, ob Sie AppSec-Administrator, Entwickler, CISO oder in einem anderen Bereich der Sicherheit tätig sind – wir können Ihrem Unternehmen dabei helfen, die mit unsicherem Code verbundenen Risiken zu reduzieren.
Eine Vorführung buchen
Alan Richardson verfügt über mehr als zwanzig Jahre Berufserfahrung in der IT-Branche. Er arbeitete als Entwickler und auf jeder Ebene der Testhierarchie, vom Tester bis hin zum Head of Testing. Als Head of Developer Relations bei Secure Code Warrior arbeitet er direkt mit Teams zusammen, um die Entwicklung von hochwertigem, sicherem Code zu verbessern. Alan ist der Autor von vier Büchern, darunter "Dear Evil Tester" und "Java For Testers". Alan hat auch Online-Schulungen courses erstellt, um Menschen beim Erlernen von technischen Web-Tests und Selenium WebDriver mit Java zu helfen. Alan veröffentlicht seine Schriften und Schulungsvideos auf SeleniumSimplified.com, EvilTester.com, JavaForTesters.com und CompendiumDev.co.uk.
Java-Fehler: Bitweise Operatoren vs. Boolesche Operatoren
> „Java Gotcha“: ein häufiger Fehler, der leicht versehentlich implementiert werden kann.
Ein recht einfacher Java-Trick, in den man versehentlich tappen kann, ist die Verwendung eines Bit-Operators anstelle eines booleschen Vergleichsoperators.
Por ejemplo, un simple error de escritura puede resultar en escribir «&» cuando realmente querías escribir «&&».
Eine gängige Heuristik, die wir beim Überprüfen des Codes lernen, lautet:
> „&“ oder „|“ in einer bedingten Anweisung sind wahrscheinlich nicht beabsichtigt.
In diesem Blogbeitrag werden wir die Heuristik untersuchen und Wege aufzeigen, wie wir dieses Codierungsproblem erkennen und beheben können.
¿Cuál es el problema? Las operaciones bit a bit funcionan bien con los valores booleanos
Die Verwendung von Bit-Operatoren mit Booleschen Werten ist vollkommen zulässig, sodass Java keinen Syntaxfehler meldet.
Wenn wir einen JUnit-Test erstellen, um eine Wahrheitstabelle sowohl für Bitwise OR (|) als auch für Bitwise AND (&) zu untersuchen, sehen wir, dass die Ausgaben des Bitwise-Operators mit der Wahrheitstabelle übereinstimmen. Angesichts dessen könnten wir denken, dass die Verwendung von Bitwise-Operatoren kein Problem darstellt.
Y Tabelle der Wahrheit
@Test
void BitwiseOperatorsAndTruthTable () {
Assertions.assertEquals (verdadero, verdadero y verdadero);
Assertions.assertEquals (falso, verdadero y falso);
Assertions.assertEquals (falso, falso y verdadero);
Assertions.assertEquals (falso, falso y falso);
}
Der Test ist bestanden, dies ist vollkommen gültiges Java.
O Tabelle der Wahrheit
@Test
anular BitwiseOperatorSorTruthTable () {
Assertions.assertEquals (verdadero, verdadero | verdadero);
Assertions.assertEquals (verdadero, verdadero | falso);
Assertions.assertEquals (verdadero, falso | verdadero);
Assertions.assertEquals (falso, falso | falso);
}
Dieser Test ist auch bestanden, warum bevorzugen wir „&&“ und „||“?
Die Bilder der Wahrheitstabelle wurden mit dem Werkzeug „Wahrheitstabelle“ von web.standfor.eduerstellt.
Problem: Kurzschlussbetrieb
Das eigentliche Problem ist der Unterschied im Verhalten zwischen bitweisen Operatoren (&, |) und booleschen Operatoren (&&, ||).
Ein Boolescher Operator ist ein Kurzschlussoperator und wertet nur das Nötigste aus.
zum Beispiel
si (args! = nulo & args.length () > 23) {
System.out.println (argumentos);
}
Im obigen Code werden beide booleschen Bedingungen ausgewertet, da der Bitweise-Operator verwendet wurde:
- Argumente! = null
- args.length () > 23
Dies macht meinen Code anfällig für eine NullPointerException, wenn args null ist, da wir immer die Überprüfung von args.length durchführen, selbst wenn args null ist, da beide booleschen Bedingungen ausgewertet werden müssen.
Bewertung von Kurzschlüssen bei booleschen Operatoren
Wenn man ein && verwendet, z. B.
si (args! = nulo && args.length () > 23) {
System.out.println (argumentos);
}
Sobald wir wissen, dass es sich um ein Argument handelt! = null wird als falsch ausgewertet, die Auswertung des Bedingungsausdrucks wird angehalten.
Wir müssen die rechte Seite nicht bewerten.
Unabhängig vom Ergebnis der Bedingung auf der rechten Seite ist der Endwert des booleschen Ausdrucks falsch.
Aber das würde im Produktionscode niemals passieren.
Dies ist ein Fehler, der leicht zu begehen ist und von statischen Analysewerkzeugen nicht immer erkannt wird.
Ich habe den folgenden Google Dork verwendet, um zu sehen, ob ich ein öffentliches Beispiel für dieses Muster finden konnte:
Dateityp: Java, wenn „! = null &”
Diese Suche ergab einen Android-Code im RootWindowContainer
isDocument = intent! = null & intent.isDocument ()
Dies ist die Art von Code, die eine Codeüberprüfung bestehen kann, da wir häufig Bit-Operatoren in Zuweisungsanweisungen verwenden, um Werte zu maskieren. In diesem Fall ist das Ergebnis jedoch dasselbe wie im vorherigen Beispiel mit der if-Anweisung. Wenn die Absicht jemals null ist, wird eine NullPointerException ausgelöst.
Sehr oft kommen wir mit dieser Konstruktion durch, weil wir häufig defensiv programmieren und redundanten Code schreiben. Die Überprüfung „¡El cheque para! = null“ kann in den meisten Anwendungsfällen redundant sein.
Es handelt sich um einen Fehler, den die Programmierer im Produktionscode gemacht haben.
Ich weiß nicht, wie aktuell die Suchergebnisse sind, aber als ich die Suche durchgeführt habe, wurden Ergebnisse mit dem Code von Google, Amazon, Apache ... und mir angezeigt.
Ein kürzlich eingereichter Extraktionsantrag in einem meiner Open-Source-Projekte diente genau dazu, diesen Fehler zu beheben.
si (escriba! =nulo y escribe.trim () .length () >0) {
Aceptar MediaTypeDefinitionsList.add (type.trim ());
}
Wie man dies findet
Als ich meinen Beispielcode in einigen statischen Analysatoren überprüft habe, hat keiner von ihnen diesen versteckten Selbstzerstörungscode erkannt.
Als Team von Secure Code Warrior haben wir ein Sensei einfaches Sensei erstellt und überprüft, das diese Frage beantworten könnte.
Da Bitwise-Operatoren vollkommen gültig sind und häufig in Zuweisungen verwendet werden, konzentrieren wir uns auf den Anwendungsfall von if-Anweisungen und die Verwendung von Bitwise &, um den problematischen Code zu finden.
buscar:
expresión:
Cualquiera de:
- en:
condición: {}
valor:
Sensible a mayúsculas y minúsculas: falso
coincidencias: «.* & . *»
Dies verwendet einen regulären Ausdruck, um mit „&” übereinzustimmen, wenn dieser als Bedingungsausdruck verwendet wird, beispielsweise in einer if-Anweisung.
Um das Problem zu beheben, haben wir uns erneut auf reguläre Ausdrücke verlassen. Dieses Mal haben wir die sed-Funktion von QuickFix verwendet, um das & im Ausdruck global durch && zu ersetzen.
Correcciones disponibles:
- nombre: «Reemplazar el operador AND bit a bit por el operador AND lógico»
acciones:
- reescribir:
a: «{{#sed}} s/&/&&/g, {{{.}}} {{/sed}}»
Endnoten
Dies deckt den häufigsten Missbrauch eines Bit-Operators ab, d. h. wenn eigentlich ein Boolescher Operator verwendet werden sollte.
Es gibt noch andere Situationen, in denen dies auftreten könnte, beispielsweise bei einer Aufgabe, aber beim Schreiben von Rezepten müssen wir versuchen, die Identifizierung von Fehlalarmen zu vermeiden, da die Rezepte sonst ignoriert oder deaktiviert werden. Wir erstellen Rezepte, die den häufigsten Vorkommnissen entsprechen. Im Zuge Sensei werden wir der Suchfunktion möglicherweise zusätzliche Spezifität hinzufügen, um mehr übereinstimmende Bedingungen abzudecken.
In seiner aktuellen Form würde dieses Rezept viele der aktuellen Anwendungsfälle identifizieren, vor allem den, der in meinem Projekt beschrieben wurde.
HINWEIS: Einige wenige Code-Krieger haben zu diesem Beispiel und der Überarbeitung der Rezepte beigetragen: Charlie Eriksen, Matthieu Calie, Robin Claerhaut, Brysen Ackx, Nathan Desmet und Downey Robersscheuten. Vielen Dank für eure Hilfe.
---
Sie können Sensei IntelliJ unter „Einstellungen\Plugins” (Mac) oder „Konfiguration\Plugins” (Windows) installieren und anschließend nach senseisicherer Code senseisuchen.
Wir haben viele Quellcodes und Rezepte für diese Blogeinträge (einschließlich dieses) im Repositorysensei des GitHub-Kontos von Secure Code Warrior.
https://github.com/securecodewarrior/sensei-blog-examples
Weitere Informationen über Sensei
Java-Fehler: Bitweise Operatoren vs. Boolesche Operatoren
> „Java Gotcha“: ein häufiger Fehler, der leicht versehentlich implementiert werden kann.
Ein recht einfacher Java-Trick, in den man versehentlich tappen kann, ist die Verwendung eines Bit-Operators anstelle eines booleschen Vergleichsoperators.
Por ejemplo, un simple error de escritura puede resultar en escribir «&» cuando realmente querías escribir «&&».
Eine gängige Heuristik, die wir beim Überprüfen des Codes lernen, lautet:
> „&“ oder „|“ in einer bedingten Anweisung sind wahrscheinlich nicht beabsichtigt.
In diesem Blogbeitrag werden wir die Heuristik untersuchen und Wege aufzeigen, wie wir dieses Codierungsproblem erkennen und beheben können.
¿Cuál es el problema? Las operaciones bit a bit funcionan bien con los valores booleanos
Die Verwendung von Bit-Operatoren mit Booleschen Werten ist vollkommen zulässig, sodass Java keinen Syntaxfehler meldet.
Wenn wir einen JUnit-Test erstellen, um eine Wahrheitstabelle sowohl für Bitwise OR (|) als auch für Bitwise AND (&) zu untersuchen, sehen wir, dass die Ausgaben des Bitwise-Operators mit der Wahrheitstabelle übereinstimmen. Angesichts dessen könnten wir denken, dass die Verwendung von Bitwise-Operatoren kein Problem darstellt.
Y Tabelle der Wahrheit
@Test
void BitwiseOperatorsAndTruthTable () {
Assertions.assertEquals (verdadero, verdadero y verdadero);
Assertions.assertEquals (falso, verdadero y falso);
Assertions.assertEquals (falso, falso y verdadero);
Assertions.assertEquals (falso, falso y falso);
}
Der Test ist bestanden, dies ist vollkommen gültiges Java.
O Tabelle der Wahrheit
@Test
anular BitwiseOperatorSorTruthTable () {
Assertions.assertEquals (verdadero, verdadero | verdadero);
Assertions.assertEquals (verdadero, verdadero | falso);
Assertions.assertEquals (verdadero, falso | verdadero);
Assertions.assertEquals (falso, falso | falso);
}
Dieser Test ist auch bestanden, warum bevorzugen wir „&&“ und „||“?
Die Bilder der Wahrheitstabelle wurden mit dem Werkzeug „Wahrheitstabelle“ von web.standfor.eduerstellt.
Problem: Kurzschlussbetrieb
Das eigentliche Problem ist der Unterschied im Verhalten zwischen bitweisen Operatoren (&, |) und booleschen Operatoren (&&, ||).
Ein Boolescher Operator ist ein Kurzschlussoperator und wertet nur das Nötigste aus.
zum Beispiel
si (args! = nulo & args.length () > 23) {
System.out.println (argumentos);
}
Im obigen Code werden beide booleschen Bedingungen ausgewertet, da der Bitweise-Operator verwendet wurde:
- Argumente! = null
- args.length () > 23
Dies macht meinen Code anfällig für eine NullPointerException, wenn args null ist, da wir immer die Überprüfung von args.length durchführen, selbst wenn args null ist, da beide booleschen Bedingungen ausgewertet werden müssen.
Bewertung von Kurzschlüssen bei booleschen Operatoren
Wenn man ein && verwendet, z. B.
si (args! = nulo && args.length () > 23) {
System.out.println (argumentos);
}
Sobald wir wissen, dass es sich um ein Argument handelt! = null wird als falsch ausgewertet, die Auswertung des Bedingungsausdrucks wird angehalten.
Wir müssen die rechte Seite nicht bewerten.
Unabhängig vom Ergebnis der Bedingung auf der rechten Seite ist der Endwert des booleschen Ausdrucks falsch.
Aber das würde im Produktionscode niemals passieren.
Dies ist ein Fehler, der leicht zu begehen ist und von statischen Analysewerkzeugen nicht immer erkannt wird.
Ich habe den folgenden Google Dork verwendet, um zu sehen, ob ich ein öffentliches Beispiel für dieses Muster finden konnte:
Dateityp: Java, wenn „! = null &”
Diese Suche ergab einen Android-Code im RootWindowContainer
isDocument = intent! = null & intent.isDocument ()
Dies ist die Art von Code, die eine Codeüberprüfung bestehen kann, da wir häufig Bit-Operatoren in Zuweisungsanweisungen verwenden, um Werte zu maskieren. In diesem Fall ist das Ergebnis jedoch dasselbe wie im vorherigen Beispiel mit der if-Anweisung. Wenn die Absicht jemals null ist, wird eine NullPointerException ausgelöst.
Sehr oft kommen wir mit dieser Konstruktion durch, weil wir häufig defensiv programmieren und redundanten Code schreiben. Die Überprüfung „¡El cheque para! = null“ kann in den meisten Anwendungsfällen redundant sein.
Es handelt sich um einen Fehler, den die Programmierer im Produktionscode gemacht haben.
Ich weiß nicht, wie aktuell die Suchergebnisse sind, aber als ich die Suche durchgeführt habe, wurden Ergebnisse mit dem Code von Google, Amazon, Apache ... und mir angezeigt.
Ein kürzlich eingereichter Extraktionsantrag in einem meiner Open-Source-Projekte diente genau dazu, diesen Fehler zu beheben.
si (escriba! =nulo y escribe.trim () .length () >0) {
Aceptar MediaTypeDefinitionsList.add (type.trim ());
}
Wie man dies findet
Als ich meinen Beispielcode in einigen statischen Analysatoren überprüft habe, hat keiner von ihnen diesen versteckten Selbstzerstörungscode erkannt.
Als Team von Secure Code Warrior haben wir ein Sensei einfaches Sensei erstellt und überprüft, das diese Frage beantworten könnte.
Da Bitwise-Operatoren vollkommen gültig sind und häufig in Zuweisungen verwendet werden, konzentrieren wir uns auf den Anwendungsfall von if-Anweisungen und die Verwendung von Bitwise &, um den problematischen Code zu finden.
buscar:
expresión:
Cualquiera de:
- en:
condición: {}
valor:
Sensible a mayúsculas y minúsculas: falso
coincidencias: «.* & . *»
Dies verwendet einen regulären Ausdruck, um mit „&” übereinzustimmen, wenn dieser als Bedingungsausdruck verwendet wird, beispielsweise in einer if-Anweisung.
Um das Problem zu beheben, haben wir uns erneut auf reguläre Ausdrücke verlassen. Dieses Mal haben wir die sed-Funktion von QuickFix verwendet, um das & im Ausdruck global durch && zu ersetzen.
Correcciones disponibles:
- nombre: «Reemplazar el operador AND bit a bit por el operador AND lógico»
acciones:
- reescribir:
a: «{{#sed}} s/&/&&/g, {{{.}}} {{/sed}}»
Endnoten
Dies deckt den häufigsten Missbrauch eines Bit-Operators ab, d. h. wenn eigentlich ein Boolescher Operator verwendet werden sollte.
Es gibt noch andere Situationen, in denen dies auftreten könnte, beispielsweise bei einer Aufgabe, aber beim Schreiben von Rezepten müssen wir versuchen, die Identifizierung von Fehlalarmen zu vermeiden, da die Rezepte sonst ignoriert oder deaktiviert werden. Wir erstellen Rezepte, die den häufigsten Vorkommnissen entsprechen. Im Zuge Sensei werden wir der Suchfunktion möglicherweise zusätzliche Spezifität hinzufügen, um mehr übereinstimmende Bedingungen abzudecken.
In seiner aktuellen Form würde dieses Rezept viele der aktuellen Anwendungsfälle identifizieren, vor allem den, der in meinem Projekt beschrieben wurde.
HINWEIS: Einige wenige Code-Krieger haben zu diesem Beispiel und der Überarbeitung der Rezepte beigetragen: Charlie Eriksen, Matthieu Calie, Robin Claerhaut, Brysen Ackx, Nathan Desmet und Downey Robersscheuten. Vielen Dank für eure Hilfe.
---
Sie können Sensei IntelliJ unter „Einstellungen\Plugins” (Mac) oder „Konfiguration\Plugins” (Windows) installieren und anschließend nach senseisicherer Code senseisuchen.
Wir haben viele Quellcodes und Rezepte für diese Blogeinträge (einschließlich dieses) im Repositorysensei des GitHub-Kontos von Secure Code Warrior.
https://github.com/securecodewarrior/sensei-blog-examples
Weitere Informationen über Sensei
Klicken Sie auf den untenstehenden Link und laden Sie die PDF-Datei dieser Ressource herunter.
Secure Code Warrior hier, um Ihrem Unternehmen dabei zu helfen, den Code während des gesamten Lebenszyklus der Softwareentwicklung zu schützen und eine Kultur zu schaffen, in der Cybersicherheit oberste Priorität hat. Ganz gleich, ob Sie AppSec-Administrator, Entwickler, CISO oder in einem anderen Bereich der Sicherheit tätig sind – wir können Ihrem Unternehmen dabei helfen, die mit unsicherem Code verbundenen Risiken zu reduzieren.
Bericht anzeigenEine Vorführung buchen
Alan Richardson verfügt über mehr als zwanzig Jahre Berufserfahrung in der IT-Branche. Er arbeitete als Entwickler und auf jeder Ebene der Testhierarchie, vom Tester bis hin zum Head of Testing. Als Head of Developer Relations bei Secure Code Warrior arbeitet er direkt mit Teams zusammen, um die Entwicklung von hochwertigem, sicherem Code zu verbessern. Alan ist der Autor von vier Büchern, darunter "Dear Evil Tester" und "Java For Testers". Alan hat auch Online-Schulungen courses erstellt, um Menschen beim Erlernen von technischen Web-Tests und Selenium WebDriver mit Java zu helfen. Alan veröffentlicht seine Schriften und Schulungsvideos auf SeleniumSimplified.com, EvilTester.com, JavaForTesters.com und CompendiumDev.co.uk.
Java-Fehler: Bitweise Operatoren vs. Boolesche Operatoren
> „Java Gotcha“: ein häufiger Fehler, der leicht versehentlich implementiert werden kann.
Ein recht einfacher Java-Trick, in den man versehentlich tappen kann, ist die Verwendung eines Bit-Operators anstelle eines booleschen Vergleichsoperators.
Por ejemplo, un simple error de escritura puede resultar en escribir «&» cuando realmente querías escribir «&&».
Eine gängige Heuristik, die wir beim Überprüfen des Codes lernen, lautet:
> „&“ oder „|“ in einer bedingten Anweisung sind wahrscheinlich nicht beabsichtigt.
In diesem Blogbeitrag werden wir die Heuristik untersuchen und Wege aufzeigen, wie wir dieses Codierungsproblem erkennen und beheben können.
¿Cuál es el problema? Las operaciones bit a bit funcionan bien con los valores booleanos
Die Verwendung von Bit-Operatoren mit Booleschen Werten ist vollkommen zulässig, sodass Java keinen Syntaxfehler meldet.
Wenn wir einen JUnit-Test erstellen, um eine Wahrheitstabelle sowohl für Bitwise OR (|) als auch für Bitwise AND (&) zu untersuchen, sehen wir, dass die Ausgaben des Bitwise-Operators mit der Wahrheitstabelle übereinstimmen. Angesichts dessen könnten wir denken, dass die Verwendung von Bitwise-Operatoren kein Problem darstellt.
Y Tabelle der Wahrheit
@Test
void BitwiseOperatorsAndTruthTable () {
Assertions.assertEquals (verdadero, verdadero y verdadero);
Assertions.assertEquals (falso, verdadero y falso);
Assertions.assertEquals (falso, falso y verdadero);
Assertions.assertEquals (falso, falso y falso);
}
Der Test ist bestanden, dies ist vollkommen gültiges Java.
O Tabelle der Wahrheit
@Test
anular BitwiseOperatorSorTruthTable () {
Assertions.assertEquals (verdadero, verdadero | verdadero);
Assertions.assertEquals (verdadero, verdadero | falso);
Assertions.assertEquals (verdadero, falso | verdadero);
Assertions.assertEquals (falso, falso | falso);
}
Dieser Test ist auch bestanden, warum bevorzugen wir „&&“ und „||“?
Die Bilder der Wahrheitstabelle wurden mit dem Werkzeug „Wahrheitstabelle“ von web.standfor.eduerstellt.
Problem: Kurzschlussbetrieb
Das eigentliche Problem ist der Unterschied im Verhalten zwischen bitweisen Operatoren (&, |) und booleschen Operatoren (&&, ||).
Ein Boolescher Operator ist ein Kurzschlussoperator und wertet nur das Nötigste aus.
zum Beispiel
si (args! = nulo & args.length () > 23) {
System.out.println (argumentos);
}
Im obigen Code werden beide booleschen Bedingungen ausgewertet, da der Bitweise-Operator verwendet wurde:
- Argumente! = null
- args.length () > 23
Dies macht meinen Code anfällig für eine NullPointerException, wenn args null ist, da wir immer die Überprüfung von args.length durchführen, selbst wenn args null ist, da beide booleschen Bedingungen ausgewertet werden müssen.
Bewertung von Kurzschlüssen bei booleschen Operatoren
Wenn man ein && verwendet, z. B.
si (args! = nulo && args.length () > 23) {
System.out.println (argumentos);
}
Sobald wir wissen, dass es sich um ein Argument handelt! = null wird als falsch ausgewertet, die Auswertung des Bedingungsausdrucks wird angehalten.
Wir müssen die rechte Seite nicht bewerten.
Unabhängig vom Ergebnis der Bedingung auf der rechten Seite ist der Endwert des booleschen Ausdrucks falsch.
Aber das würde im Produktionscode niemals passieren.
Dies ist ein Fehler, der leicht zu begehen ist und von statischen Analysewerkzeugen nicht immer erkannt wird.
Ich habe den folgenden Google Dork verwendet, um zu sehen, ob ich ein öffentliches Beispiel für dieses Muster finden konnte:
Dateityp: Java, wenn „! = null &”
Diese Suche ergab einen Android-Code im RootWindowContainer
isDocument = intent! = null & intent.isDocument ()
Dies ist die Art von Code, die eine Codeüberprüfung bestehen kann, da wir häufig Bit-Operatoren in Zuweisungsanweisungen verwenden, um Werte zu maskieren. In diesem Fall ist das Ergebnis jedoch dasselbe wie im vorherigen Beispiel mit der if-Anweisung. Wenn die Absicht jemals null ist, wird eine NullPointerException ausgelöst.
Sehr oft kommen wir mit dieser Konstruktion durch, weil wir häufig defensiv programmieren und redundanten Code schreiben. Die Überprüfung „¡El cheque para! = null“ kann in den meisten Anwendungsfällen redundant sein.
Es handelt sich um einen Fehler, den die Programmierer im Produktionscode gemacht haben.
Ich weiß nicht, wie aktuell die Suchergebnisse sind, aber als ich die Suche durchgeführt habe, wurden Ergebnisse mit dem Code von Google, Amazon, Apache ... und mir angezeigt.
Ein kürzlich eingereichter Extraktionsantrag in einem meiner Open-Source-Projekte diente genau dazu, diesen Fehler zu beheben.
si (escriba! =nulo y escribe.trim () .length () >0) {
Aceptar MediaTypeDefinitionsList.add (type.trim ());
}
Wie man dies findet
Als ich meinen Beispielcode in einigen statischen Analysatoren überprüft habe, hat keiner von ihnen diesen versteckten Selbstzerstörungscode erkannt.
Als Team von Secure Code Warrior haben wir ein Sensei einfaches Sensei erstellt und überprüft, das diese Frage beantworten könnte.
Da Bitwise-Operatoren vollkommen gültig sind und häufig in Zuweisungen verwendet werden, konzentrieren wir uns auf den Anwendungsfall von if-Anweisungen und die Verwendung von Bitwise &, um den problematischen Code zu finden.
buscar:
expresión:
Cualquiera de:
- en:
condición: {}
valor:
Sensible a mayúsculas y minúsculas: falso
coincidencias: «.* & . *»
Dies verwendet einen regulären Ausdruck, um mit „&” übereinzustimmen, wenn dieser als Bedingungsausdruck verwendet wird, beispielsweise in einer if-Anweisung.
Um das Problem zu beheben, haben wir uns erneut auf reguläre Ausdrücke verlassen. Dieses Mal haben wir die sed-Funktion von QuickFix verwendet, um das & im Ausdruck global durch && zu ersetzen.
Correcciones disponibles:
- nombre: «Reemplazar el operador AND bit a bit por el operador AND lógico»
acciones:
- reescribir:
a: «{{#sed}} s/&/&&/g, {{{.}}} {{/sed}}»
Endnoten
Dies deckt den häufigsten Missbrauch eines Bit-Operators ab, d. h. wenn eigentlich ein Boolescher Operator verwendet werden sollte.
Es gibt noch andere Situationen, in denen dies auftreten könnte, beispielsweise bei einer Aufgabe, aber beim Schreiben von Rezepten müssen wir versuchen, die Identifizierung von Fehlalarmen zu vermeiden, da die Rezepte sonst ignoriert oder deaktiviert werden. Wir erstellen Rezepte, die den häufigsten Vorkommnissen entsprechen. Im Zuge Sensei werden wir der Suchfunktion möglicherweise zusätzliche Spezifität hinzufügen, um mehr übereinstimmende Bedingungen abzudecken.
In seiner aktuellen Form würde dieses Rezept viele der aktuellen Anwendungsfälle identifizieren, vor allem den, der in meinem Projekt beschrieben wurde.
HINWEIS: Einige wenige Code-Krieger haben zu diesem Beispiel und der Überarbeitung der Rezepte beigetragen: Charlie Eriksen, Matthieu Calie, Robin Claerhaut, Brysen Ackx, Nathan Desmet und Downey Robersscheuten. Vielen Dank für eure Hilfe.
---
Sie können Sensei IntelliJ unter „Einstellungen\Plugins” (Mac) oder „Konfiguration\Plugins” (Windows) installieren und anschließend nach senseisicherer Code senseisuchen.
Wir haben viele Quellcodes und Rezepte für diese Blogeinträge (einschließlich dieses) im Repositorysensei des GitHub-Kontos von Secure Code Warrior.
https://github.com/securecodewarrior/sensei-blog-examples
Weitere Informationen über Sensei
Inhaltsverzeichnis
Alan Richardson verfügt über mehr als zwanzig Jahre Berufserfahrung in der IT-Branche. Er arbeitete als Entwickler und auf jeder Ebene der Testhierarchie, vom Tester bis hin zum Head of Testing. Als Head of Developer Relations bei Secure Code Warrior arbeitet er direkt mit Teams zusammen, um die Entwicklung von hochwertigem, sicherem Code zu verbessern. Alan ist der Autor von vier Büchern, darunter "Dear Evil Tester" und "Java For Testers". Alan hat auch Online-Schulungen courses erstellt, um Menschen beim Erlernen von technischen Web-Tests und Selenium WebDriver mit Java zu helfen. Alan veröffentlicht seine Schriften und Schulungsvideos auf SeleniumSimplified.com, EvilTester.com, JavaForTesters.com und CompendiumDev.co.uk.
Secure Code Warrior hier, um Ihrem Unternehmen dabei zu helfen, den Code während des gesamten Lebenszyklus der Softwareentwicklung zu schützen und eine Kultur zu schaffen, in der Cybersicherheit oberste Priorität hat. Ganz gleich, ob Sie AppSec-Administrator, Entwickler, CISO oder in einem anderen Bereich der Sicherheit tätig sind – wir können Ihrem Unternehmen dabei helfen, die mit unsicherem Code verbundenen Risiken zu reduzieren.
Eine Vorführung buchenHerunterladenRessourcen für den Einstieg
Themen und Inhalte der Schulung zum Thema sicherer Code
Unsere branchenführenden Inhalte werden ständig weiterentwickelt, um sich an die sich wandelnde Landschaft der Softwareentwicklung anzupassen und dabei Ihre Rolle zu berücksichtigen. Es werden Themen angeboten, die von KI bis hin zu XQuery-Injektion reichen und sich an verschiedene Positionen richten, von Architekten und Ingenieuren bis hin zu Produktmanagern und Qualitätskontrolleuren. Verschaffen Sie sich einen Überblick über unser Angebot an Inhalten nach Thema und Funktion.
Die Kamer van Koophandel setzt Maßstäbe für entwicklergesteuerte Sicherheit in großem Maßstab
Die Kamer van Koophandel berichtet, wie sie sicheres Codieren durch rollenbasierte Zertifizierungen, Trust Score-Benchmarking und eine Kultur der gemeinsamen Verantwortung für Sicherheit in die tägliche Entwicklungsarbeit integriert hat.
%20(1).avif)
.avif)
Bedrohungsmodellierung mit KI: So wird jeder Entwickler zum Bedrohungsmodellierer
Sie werden besser gerüstet sein, um Entwicklern dabei zu helfen, Ideen und Techniken zur Bedrohungsmodellierung mit den KI-Tools zu kombinieren, die sie bereits verwenden, um die Sicherheit zu erhöhen, die Zusammenarbeit zu verbessern und von Anfang an widerstandsfähigere Software zu entwickeln.
Ressourcen für den Einstieg
Cybermon ist zurück: Die KI-Missionen von Beat the Boss sind jetzt auf Abruf verfügbar.
Cybermon 2025 Beat the Boss ist jetzt das ganze Jahr über bei SCW verfügbar. Implementieren Sie fortschrittliche KI- und LLM-Sicherheitsherausforderungen, um die sichere Entwicklung von KI in großem Maßstab zu stärken.
Erläuterung des Gesetzes zur Cyberresilienz: Was bedeutet es für die Entwicklung sicherer Software?
Entdecken Sie, was das EU-Gesetz zur Cyberresilienz (CRA) verlangt, für wen es gilt und wie sich Ingenieurteams mit sicheren Designpraktiken, der Vermeidung von Schwachstellen und der Entwicklung von Fähigkeiten für Entwickler darauf vorbereiten können.
SCW feiert sein 11-jähriges Bestehen: eine Lektion in Echtzeit über Anpassungsfähigkeit und kontinuierliche Verbesserung
2025 war ein großartiges Jahr für KI, Cybersicherheit und SCW. Ich gehe mit ruhiger Zuversicht und dem Optimismus, den nur harte und lohnende Arbeit mit sich bringen kann, auf das Jahr 2026 zu.