+ Welcome to HackTools 馃洜
+ +
+ 
+ 
+ 
+ 
+ 
+ + Introduction + — + Preview + — + Install + — + Build + — + Support +
+
+ + Introduction + — + Preview + — + Install + — + Build + — + Support +
+
+
+
+
+
+
+ Chromium based browser
+
+ Mozilla Firefox
+
+ Instructions to build for Safari
+
-## Verifying the integrity of the page
+Then click on the **load unpacked** button in the top left corner
-The expected SHA256 checksum hash of the .html file containing the page is:
+
- c7398059dffd25fa8a9d81c570250887fba61dc4eafcfca42f9081196389ed05
+Once you clicked on the button you just need to select the **dist folder** and that's it ! 馃帀
-If loading the page from a web server, you can verify that the checksum hash of the .html file downloaded from the web server matches the expected checksum hash using the [Page Integrity browser extension](https://www.pageintegrity.net/).
-If running the page offline, it is recommended that you verify that the checksum hash of the .html file matches the expected checksum hash before opening the file in your web browser.
+
-## Contributing
+## Authors
-Pull requests are welcome.
+馃懁 **Ludovic COULON** & **Riadh BOUCHAHOUA**
-## License
+## Show your support
-This project is licensed under the [GPL-3.0](https://www.gnu.org/licenses/gpl-3.0.en.html) open source license.
+You can give a 猸愶笍 if this project helped you !
-## Contact
+Note that this project is maintained, developed and made available for **free**, you can offer us a coffee, it will be very **encouraging and greatly appreciated** 馃槉
-Please [contact MTI](https://www.meixler-tech.com/contact.php) for any questions or comments concerning this project.
+
diff --git a/Read.me.text.txt b/Read.me.text.txt
new file mode 100644
index 0000000..e946b9f
--- /dev/null
+++ b/Read.me.text.txt
@@ -0,0 +1,68 @@
+How to Hack Snapchat, New Tip 2024 [UPDATED]
+
+Understanding Snapchat's security features
+Risks and consequences of hacking Snapchat
+Ethical implications of hacking Snapchat
+Common methods used for hacking Snapchat
+The importance of strong passwords and two-factor authentication
+Protecting your Snapchat account from hacking attempts
+Reporting and preventing hacking incidents on Snapchat
+Staying updated on the latest Snapchat security features
+Conclusion: Promoting responsible and ethical use of Snapchat
+Are you ready to elevate your Snapchat experience to a whole new level? With the constantly evolving landscape of social media, staying ahead of the game is essential. In this comprehensive guide, we will unveil a new tip for the year 2024 that will revolutionize the way you use Snapchat. Get ready to discover hidden features, master new techniques, and unlock the full potential of your Snapchat account.
+
+Understanding Snapchat's Security Features
+
+Snapchat prides itself on its commitment to user privacy and security. With features like end-to-end encryption and self-destructing messages, the platform aims to provide a safe environment for users to share moments with their friends. However, understanding the security mechanisms put in place by Snapchat is crucial before delving into the realm of hacking. By familiarizing yourself with how Snapchat protects user data, you can better appreciate the implications of bypassing these safeguards.
+
+When exploring the world of Snapchat hacking, it's important to tread carefully and be aware of the risks involved. While hacking may offer shortcuts to certain features or functionalities, it can also lead to serious consequences. From potential legal repercussions to damage to personal relationships, the risks of hacking Snapchat extend far beyond the digital realm. Before attempting any hacking techniques, it's essential to weigh the potential risks against the benefits and consider the ethical implications of your actions.
+
+Risks and Consequences of Hacking Snapchat
+
+Hacking into someone's Snapchat account without their consent is not only a violation of privacy but also a breach of trust. The consequences of unauthorized access to someone's private messages or photos can be severe, resulting in legal action and irreparable damage to relationships. Additionally, engaging in hacking activities can tarnish your reputation and undermine your credibility in both personal and professional spheres. As tempting as it may be to explore the hidden corners of Snapchat, it's crucial to consider the potential repercussions before crossing ethical boundaries.
+
+When it comes to hacking, the line between curiosity and malice can easily blur. While the allure of uncovering secrets or gaining an edge over others may be strong, it's important to approach hacking with caution and respect for others' privacy. By understanding the risks and consequences associated with hacking Snapchat, you can make informed decisions and uphold ethical standards in your online interactions. Remember, the choices you make in the digital world can have real-world consequences, so proceed with caution and integrity.
+
+Ethical Implications of Hacking Snapchat
+
+As technology continues to advance at a rapid pace, the ethical considerations surrounding hacking have become more complex. While hacking can be viewed as a means of exploring and understanding digital systems, it also raises questions about privacy, consent, and the boundaries of online behavior. When it comes to hacking Snapchat, it's essential to consider the ethical implications of your actions and the impact they may have on others.
+
+Before embarking on any hacking endeavors, take a moment to reflect on your motivations and the potential consequences of your actions. Ask yourself whether the knowledge or access you seek is worth compromising your values and integrity. By approaching hacking with a strong ethical framework, you can navigate the digital landscape responsibly and contribute to a safer and more respectful online community. Remember, ethical hacking is not about breaking rules but about using your skills for positive purposes and upholding the principles of honesty and respect.
+
+Common Methods Used for Hacking Snapchat
+
+When it comes to hacking Snapchat, there are various methods and techniques that hackers may employ to gain unauthorized access to accounts or data. From phishing scams and password cracking to social engineering tactics, hackers use a range of strategies to exploit vulnerabilities in Snapchat's security defenses. By familiarizing yourself with these common hacking methods, you can better protect your own account and recognize potential threats.
+
+Phishing remains one of the most prevalent methods used by hackers to trick users into revealing their login credentials. By posing as a legitimate entity, such as Snapchat support or a trusted friend, hackers lure unsuspecting users into sharing their usernames and passwords. Additionally, password cracking techniques involve using software tools to guess or brute force passwords, exploiting weak or easily guessable combinations. Social engineering tactics, on the other hand, rely on manipulating users into divulging sensitive information through psychological manipulation or deception.
+
+The Importance of Strong Passwords and Two-Factor Authentication
+
+One of the most effective ways to safeguard your Snapchat account against hacking attempts is by using strong passwords and enabling two-factor authentication. A strong password should be complex, unique, and difficult to guess, incorporating a combination of letters, numbers, and special characters. Avoid using easily guessable information, such as your birthdate or pet's name, and consider using a password manager to generate and store secure passwords.
+
+In addition to using strong passwords, enabling two-factor authentication adds an extra layer of security to your Snapchat account. By requiring a verification code sent to your mobile device or email address, two-factor authentication ensures that even if your password is compromised, unauthorized access is prevented. Take advantage of this additional security feature to protect your account from hacking attempts and enhance your overall online security posture.
+
+Protecting Your Snapchat Account from Hacking Attempts
+
+In the ever-evolving landscape of cybersecurity threats, protecting your Snapchat account from hacking attempts requires vigilance and proactive measures. Keep your account secure by regularly updating your password, being cautious of phishing attempts, and monitoring your account activity for any suspicious behavior. If you suspect that your account has been compromised, act quickly to change your password, review your security settings, and report any unauthorized activity to Snapchat support.
+
+To further enhance the security of your Snapchat account, consider limiting the information you share publicly, adjusting your privacy settings to control who can view your snaps and stories, and being selective about accepting friend requests. By taking proactive steps to secure your account and stay informed about the latest security threats, you can reduce the risk of falling victim to hacking attempts and protect your personal information from malicious actors.
+
+Reporting and Preventing Hacking Incidents on Snapchat
+
+If you encounter a hacking incident on Snapchat, whether it's your own account or someone else's, it's important to take immediate action to report and prevent further damage. Contact Snapchat support to report any unauthorized access, suspicious activity, or security breaches, providing as much detail as possible to aid in their investigation. By alerting Snapchat to potential hacking incidents, you can help protect other users and contribute to a safer online environment.
+
+In addition to reporting hacking incidents, take proactive steps to prevent future breaches by staying informed about the latest security updates and best practices. Keep an eye out for phishing scams, suspicious links, and unusual account activity, and be cautious about sharing sensitive information online. By remaining vigilant and proactive in your approach to online security, you can minimize the risk of falling victim to hacking attempts and protect your digital identity from unauthorized access.
+
+Staying Updated on the Latest Snapchat Security Features
+
+As Snapchat continues to evolve and introduce new features, staying informed about the latest security updates is essential to safeguarding your account and personal information. Keep an eye out for announcements from Snapchat regarding security enhancements, privacy settings, and tips for protecting your account from hacking attempts. By staying proactive and informed, you can adapt to changing threats and maintain a secure online presence.
+
+Whether it's implementing new security measures, updating your privacy settings, or learning about potential vulnerabilities, staying updated on the latest Snapchat security features empowers you to take control of your digital security. By remaining proactive and vigilant in your approach to online safety, you can enjoy a worry-free Snapchat experience and protect your personal information from unauthorized access.
+
+Conclusion: Promoting Responsible and Ethical Use of Snapchat
+
+In conclusion, hacking Snapchat may offer shortcuts to hidden features or enhanced functionality, but it also comes with significant risks and ethical considerations. As users of social media platforms, it's essential to prioritize responsible and ethical behavior in our online interactions and respect the privacy and security of others. By understanding the implications of hacking, safeguarding our accounts against unauthorized access, and promoting a culture of integrity and respect, we can contribute to a safer and more trustworthy online community.
+
+Remember, the choices we make online have real-world consequences, and it's up to each of us to uphold ethical standards and protect our digital identities. By approaching Snapchat hacking with caution, integrity, and a commitment to ethical behavior, we can enjoy the platform to its fullest while maintaining respect for ourselves and others. Let's strive to be responsible digital citizens and promote a culture of honesty, integrity, and respect in all our online interactions.
+
+snapchat hack hack snapchat how to hack someones snapchat how to hack into someones snapchat how to hack snapchat how to hack into snapchat how to hack a snapchat snapchat score hack how to hack a snapchat account how to hack snapchat accounts hack snapchat account hack into someones snapchat snapchat password hack snapchat hack free hack someone snapchat how to hack someone snapchat hack snapchat password how to hack into someone snapchat snapchat hack tools hack someones snapchat hack snapchat tool unlock snapchat account hack can i hack snapchat free snapchat hack snapchat hack tool hack snapchat free hack snapchat for free snapchat account hack how to hack snapchat account app to hack snapchat snapchat screenshot hack how to hack snapchat password on android snapchat hack apps apps to hack snapchat snapchat geofilter hack hack snapchat app can someone hack your snapchat by adding you how to hack someone's snapchat how to see someones bestfriends on snapchat hack snapchat trophies hack how to hack someones snapchat 2016 hack a snapchat account snapchat hack password how to hack someones snapchat password online how to hack someones snapchat 2021 snapchat hack app snapchat hack screenshot snapchat hack no offers snapchat timer hack how to hack someones snapchat no download
\ No newline at end of file
diff --git a/Save.md b/Save.md
new file mode 100644
index 0000000..e986626
--- /dev/null
+++ b/Save.md
@@ -0,0 +1,114 @@
+# Save action
+
+The save action saves a cache. It works similarly to the `cache` action except that it doesn't first do a restore. This action provides granular ability to save a cache without having to restore it, or to do a save at any stage of the workflow job -- not only in post phase.
+
+## Documentation
+
+### Inputs
+
+* `key` - An explicit key for a cache entry. See [creating a cache key](../README.md#creating-a-cache-key).
+* `path` - A list of files, directories, and wildcard patterns to cache. See [`@actions/glob`](https://github.com/actions/toolkit/tree/main/packages/glob) for supported patterns.
+* `upload-chunk-size` - The chunk size used to split up large files during upload, in bytes
+
+### Outputs
+
+This action has no outputs.
+
+## Use cases
+
+
+### Only save cache
+
+If you are using separate jobs for generating common artifacts and sharing them across jobs, this action will take care of your cache saving needs.
+
+```yaml
+steps:
+ - uses: actions/checkout@v4
+
+ - name: Install Dependencies
+ run: /install.sh
+
+ - name: Build artifacts
+ run: /build.sh
+
+ - uses: actions/cache/save@v4
+ id: cache
+ with:
+ path: path/to/dependencies
+ key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
+```
+
+### Re-evaluate cache key while saving
+
+With this save action, the key can now be re-evaluated while executing the action. This helps in cases where lockfiles are generated during the build.
+
+Let's say we have a restore step that computes a key at runtime.
+
+#### Restore a cache
+
+```yaml
+uses: actions/cache/restore@v4
+id: restore-cache
+with:
+ key: cache-${{ hashFiles('**/lockfiles') }}
+```
+
+#### Case 1 - Where a user would want to reuse the key as it is
+```yaml
+uses: actions/cache/save@v4
+with:
+ key: ${{ steps.restore-cache.outputs.cache-primary-key }}
+```
+
+#### Case 2 - Where the user would want to re-evaluate the key
+
+```yaml
+uses: actions/cache/save@v4
+with:
+ key: npm-cache-${{hashfiles(package-lock.json)}}
+```
+
+### Always save cache
+
+There are instances where some flaky test cases would fail the entire workflow and users would get frustrated because the builds would run for hours and the cache couldn't be saved as the workflow failed in between.
+For such use-cases, users now have the ability to use the `actions/cache/save` action to save the cache by using an [`always()`](https://docs.github.com/actions/writing-workflows/choosing-what-your-workflow-does/expressions#always) condition.
+This way the cache will always be saved if generated, or a warning will be generated that nothing is found on the cache path. Users can also use the `if` condition to only execute the `actions/cache/save` action depending on the output of previous steps. This way they get more control of when to save the cache.
+
+To avoid saving a cache that already exists, the `cache-hit` output from a restore step should be checked.
+
+The `cache-primary-key` output from the restore step should also be used to ensure
+the cache key does not change during the build if it's calculated based on file contents.
+
+```yaml
+name: Always Caching Primes
+
+on: push
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Restore cached Primes
+ id: cache-primes-restore
+ uses: actions/cache/restore@v4
+ with:
+ key: ${{ runner.os }}-primes
+ path: |
+ path/to/dependencies
+ some/other/dependencies
+
+ # Intermediate workflow steps
+
+ - name: Always Save Primes
+ id: cache-primes-save
+ if: always() && steps.cache-primes-restore.outputs.cache-hit != 'true'
+ uses: actions/cache/save@v4
+ with:
+ key: ${{ steps.cache-primes-restore.outputs.cache-primary-key }}
+ path: |
+ path/to/dependencies
+ some/other/dependencies
+```
diff --git a/Script.js b/Script.js
new file mode 100644
index 0000000..0d14376
--- /dev/null
+++ b/Script.js
@@ -0,0 +1,248 @@
+
+/* Reglas de encriptaci贸n:
+"e" es convertido para "enter"
+"i" es convertido para "imes"
+"a" es convertido para "ai"
+"o" es convertido para "ober"
+"u" es convertido para "ufat"
+Solo letras minusculas
+No se permite acentuaci贸n de palabras
+*/
+
+/* Reglas de desencriptaci贸n:
+"enter" es convertido para "e"
+"imes" es convertido para "i"
+"ai" es convertido para "a"
+"ober" es convertido para "o"
+"ufat" es convertido para "u"
+Solo letras minusculas
+No se permite acentuaci贸n de palabras
+*/
+
+//Inica logica de ecriptacion
+
+//Crear objeto documento para se帽alar el boton
+
+var botonDes = document.querySelector("#btn-desencriptar");
+
+botonDes.addEventListener("click", function(event){
+ event.preventDefault();
+ //console.log("This is desencriptacion");
+ var desencriptar = document.querySelector("#input-texto").value;
+ //console.log(desencriptar);
+ var mensajeDes = document.querySelector("#msg");
+ desencriptar = desencriptar.toLowerCase();
+ var desencriptar2 = "";
+
+ //Detectar substring, luego cortar el string, luego meter la vocal en el lugar correcto, luego sumar los substring
+ //Finalmente unir todos los substring
+
+
+ //Detectar todas las ocurrencias de encriptaci贸n
+
+
+ /*
+ var detectarA = desencriptar.indexOf("ai");
+ var detectarE = desencriptar.indexOf("enter");
+ var detectarI = desencriptar.indexOf("imes");
+ var detectarO = desencriptar.indexOf("ober");
+ var detectarU = desencriptar.indexOf("ufat");
+ */
+
+ function seekDestroy (secuencia){
+ //First the seek part
+ //var detectar = desencriptar.indexOf(secuencia);
+ var letra = "";
+ if (secuencia == "ai"){
+ letra = "a";
+ console.log("Entro en ai " + letra);
+ }else if (secuencia == "enter"){
+ letra = "e";
+ console.log("Entro en enter " + letra);
+ }else if (secuencia == "imes"){
+ letra = "i";
+ console.log("Entro en imes " + letra);
+ }else if (secuencia == "ober"){
+ letra = "o"
+ console.log("Entro en ober " + letra);
+ }else if (secuencia == "ufat"){
+ letra = "u";
+ console.log("Entro en ufat " + letra);
+ }
+ /*
+ var detenerWhile = true;
+ var count = 0;
+ while(detenerWhile){
+ if(detectar != -1){
+
+ console.log("contando las iteraciones " + count + "This is detectar " + detectar);
+
+ var res = desencriptar.split(secuencia);
+ console.log("this is res after split "+ res);
+ res.splice(detectar,0,letra);
+ console.log("index of primero" + res.indexOf("a"));
+ console.log("This is res after splice " + res)
+ console.log("index of primero" + res.indexOf("a"));
+ var res2 = res.join("");
+ console.log("this is res2 after join "+ res2);
+
+ desencriptar = res2 //a la variable que le hiciste todas las modificaciones
+ count++
+ var detectar = desencriptar.indexOf(secuencia);
+
+
+
+ }else if (detectar == -1) {
+ detenerWhile = false;
+ }
+ if(count == 5){
+ detenerWhile = false;
+ }
+
+ }
+ */
+ desencriptar = desencriptar.replaceAll(secuencia, letra);
+ console.log("This is desencriptar " + desencriptar);
+
+
+ //End of seek part
+
+
+
+
+ //Replace by going just one sequence at a time
+
+ //End of Replace part
+ console.log("this is desencriptar final " + desencriptar)
+ return desencriptar;
+
+ }
+
+ //Final de detectar todas las ocurrencias de la encriptaci贸n
+
+ /*
+ var detectorIndice = [];
+
+
+ if(detectarE != -1){
+ var resE = desencriptar.split("enter");
+
+ console.log("this is resE first "+ resE);
+ resE.splice(detectarE,0,"e");
+ var resE2 = resE.join("");
+ console.log("this is resE after splice and join "+ resE2);
+ var detectarA = resE2.indexOf("ai");
+ console.log("This is detectarA " + detectarA);
+ }
+ else{
+ var detectarA = resE2.indexOf("ai");
+ }
+ if(detectarA != -1){
+ var resA = resE2.split("ai");
+ //console.log("this is resE first "+ resE);
+ resA.splice(detectarA,0,"a");
+ var resA2 = resA.join("");
+ var detectarU = resA2.indexOf("ufat");
+ console.log("This is resA after join " + resA2);
+ }
+
+ */
+
+ //console.log("This should be the final product "+resO2);
+
+ /*var resA = desencriptar.split("ai");
+ var resI = desencriptar.split("imes");
+ var resO = desencriptar.split("ober");
+ var resU = desencriptar.split("ufat");
+ */
+
+
+ seekDestroy("ai");
+ seekDestroy("enter");
+ seekDestroy("imes");
+ seekDestroy("ober");
+ seekDestroy("ufat");
+ mensajeDes.value = desencriptar;
+
+})
+
+//Termina logina de desencriptacion
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//Inicia logica de ecriptacion
+
+var botonEnc = document.querySelector("#btn-encriptar");
+
+// hacer funcionar el click del boton y que imprima "codificando". Despues de imprimir codificando, pasamos a imprimir el
+// input de la caja de texto
+botonEnc.addEventListener("click", function(event){
+ event.preventDefault();
+ // Tomar el input de la caja de texto e imprimirlo en la consola
+ var textoEnc = document.querySelector("#input-texto");
+ var encriptado = textoEnc.value;
+ //console.log(typeof(encriptado));
+ encriptado = encriptado.toLowerCase();
+ var encriptadoFinal = encriptado.split('');
+ for(var i = 0; i < encriptadoFinal.length; i++){
+ //console.log("this encriptado[i] " + encriptado[i]);
+ if(encriptadoFinal[i] == "a"){
+ encriptadoFinal[i] = "ai";
+
+ } else if(encriptadoFinal[i] == "e"){
+ encriptadoFinal[i] = "enter";
+
+ } else if(encriptadoFinal[i] == "i"){
+ encriptadoFinal[i] = "imes";
+ } else if(encriptadoFinal[i] == "o"){
+ encriptadoFinal[i] = "ober";
+ } else if(encriptadoFinal[i] == "u"){
+ encriptadoFinal[i] = "ufat";
+ }
+
+
+ }
+ var encriptadoFinal2 = encriptadoFinal.join("");
+ var escribirEnc = document.querySelector("#msg");
+ escribirEnc.value = encriptadoFinal2;
+ console.log(encriptadoFinal2);
+//console.log("this length "+encriptado.length);
+
+})
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/StaticInitializationVector.ql.txt b/StaticInitializationVector.ql.txt
new file mode 100644
index 0000000..258e0f8
--- /dev/null
+++ b/StaticInitializationVector.ql.txt
@@ -0,0 +1,21 @@
+/**
+ * @name Using a static initialization vector for encryption
+ * @description An initialization vector (IV) used for ciphers of certain modes (such as CBC or GCM) should be unique and unpredictable, to maximize encryption and prevent dictionary attacks.
+ * @kind path-problem
+ * @problem.severity warning
+ * @security-severity 7.5
+ * @precision high
+ * @id java/static-initialization-vector
+ * @tags security
+ * external/cwe/cwe-329
+ * external/cwe/cwe-1204
+ */
+
+import java
+import semmle.code.java.security.StaticInitializationVectorQuery
+import StaticInitializationVectorFlow::PathGraph
+
+from StaticInitializationVectorFlow::PathNode source, StaticInitializationVectorFlow::PathNode sink
+where StaticInitializationVectorFlow::flowPath(source, sink)
+select sink.getNode(), source, sink, "A $@ should not be used for encryption.", source.getNode(),
+ "static initialization vector"
diff --git a/decrypt_photos.txt b/decrypt_photos.txt
new file mode 100644
index 0000000..ca6d070
--- /dev/null
+++ b/decrypt_photos.txt
@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+## Copyright (c) 2014, Fundaci贸n Dr. Manuel Sadosky. Todos los derechos reservados.
+##
+## La redistribuci贸n y el uso en las formas de c贸digo fuente y binario, con o sin
+## modificaciones, est谩n permitidos siempre que se cumplan las siguientes condiciones:
+##
+## 1. Las redistribuciones del c贸digo fuente deben conservar el aviso de copyright
+## anterior, esta lista de condiciones y el siguiente descargo de responsabilidad.
+##
+## 2. Las redistribuciones en formato binario deben reproducir el aviso de copyright
+## anterior, esta lista de condiciones y la siguiente renuncia en la documentaci贸n
+## y/u otros materiales suministrados con la distribuci贸n.
+##
+## ESTE SOFTWARE SE SUMINISTRA POR LA Fundaci贸n Dr. Manuel Sadosky ''COMO EST脕'' Y CUALQUIER
+## GARANT脥A EXPRESA O IMPL脥CITAS, INCLUYENDO, PERO NO LIMITADO A, LAS GARANT脥AS
+## IMPL脥CITAS DE COMERCIALIZACI脫N Y APTITUD PARA UN PROP脫SITO DETERMINADO SON
+## RECHAZADAS. EN NING脷N CASO Fundaci贸n Dr. Manuel Sadosky SER脕 RESPONSABLE POR NING脷N
+## DA脩O DIRECTO, INDIRECTO, INCIDENTAL, ESPECIAL, EJEMPLAR O CONSECUENTE (INCLUYENDO,
+## PERO NO LIMITADO A, LA ADQUISICI脫N DE BIENES O SERVICIOS; LA P脡RDIDA DE USO, DE
+## DATOS O DE BENEFICIOS; O INTERRUPCI脫N DE LA ACTIVIDAD EMPRESARIAL) O POR
+## CUALQUIER TEOR脥A DE RESPONSABILIDAD, YA SEA POR CONTRATO, RESPONSABILIDAD ESTRICTA
+## O AGRAVIO (INCLUYENDO NEGLIGENCIA O CUALQUIER OTRA CAUSA) QUE SURJA DE CUALQUIER
+## MANERA DEL USO DE ESTE SOFTWARE, INCLUSO SI SE HA ADVERTIDO DE LA POSIBILIDAD DE
+## TALES DA脩OS.
+##
+## Las opiniones y conclusiones contenidas en el software y la documentaci贸n son las
+## de los autores y no deben interpretarse como la representaci贸n de las pol铆ticas
+## oficiales, ya sea expresa o impl铆cita, de Fundaci贸n Dr. Manuel Sadosky .
+##
+## Decifrado de imagenes de Snapchat version 5.0.34.10
+## Author: Joaqu铆n Rinaudo
+##
+
+import subprocess
+import shlex
+import md5
+from hashlib import md5
+from Crypto.Cipher import AES
+from Crypto import Random
+import json
+import time
+import os
+import base64
+import re
+
+def run_get_output(command):
+ try:
+ return subprocess.check_output(shlex.split(command),stderr=subprocess.STDOUT)
+ except subprocess.CalledProcessError as grepexc:
+ return grepexc.output
+
+def run_blocking_cmd(command):
+ return subprocess.call(shlex.split(command),stdout=subprocess.PIPE,stderr=subprocess.PIPE)
+
+def get_android_id():
+ try:
+ android_id = run_get_output(''' adb shell content query --uri content://settings/secure --projection name:value --where "name=\\'android_id\\'" ''')
+ p = re.compile('Row: 0 name=android_id, value=(.*)')
+ android_id = p.findall(android_id)[0].strip()
+ except:
+ android_id = run_get_output(''' adb shell settings get secure android_id ''').strip()
+ print android_id
+ return android_id
+
+def get_version():
+ version = run_get_output(''' adb shell dumpsys package com.snapchat.android ''')
+ p = re.compile('versionName=(.*)')
+ print p.findall(version)[0].strip()
+ return p.findall(version)[0].strip()
+
+def pull_bananas_cache_file():
+ version38 = ''
+ if VERSION >= '5.0.38.1':
+ version38 = '1'
+ run_blocking_cmd(''' adb pull /data/data/com.snapchat.android/cache/bananas%s encrypted_bananas_file ''' %version38)
+
+def snapchat_bananas_password():
+ m = md5()
+ m.update( get_android_id() )
+ m.update('seems legit...')
+ return m.hexdigest()
+
+def decrypt_bananas_file():
+ with open("encrypted_bananas_file") as encrypted_bananas:
+ with open("decrypted_bananas_file",'w') as decrypted_bananas:
+ cipher = AES.new(snapchat_bananas_password(), AES.MODE_ECB)
+ decrypt_file(encrypted_bananas,decrypted_bananas,cipher )
+
+def pull_images():
+ run_blocking_cmd(''' adb pull /data/data/com.snapchat.android/cache/received_image_snaps/ encrypted_received_image_snaps/ ''')
+
+def extract_key_and_iv(json_bananas):
+ if VERSION < '5.0.38.1':
+ key= json_bananas['a']
+ iv= json_bananas['b']
+ else:
+ key= json_bananas[0]
+ iv= json_bananas[1]
+ return (base64.b64decode(key).encode('hex'),base64.b64decode(iv).encode('hex'))
+
+def decrypt_images():
+ if not os.path.exists('decrypted_received_image_snaps'): os.makedirs('decrypted_received_image_snaps')
+ with open("decrypted_bananas_file") as json_file:
+ bananas = json.loads(json_file.read().decode('utf8'))
+ if not bananas.get('snapKeysAndIvs',None):
+ print "Images were already viewed, the key and IV were deleted from the /cache/bananas file. Try reopening Snapchat to check if images where downloaded."
+ exit(0)
+ json_bananas = json.loads(bananas['snapKeysAndIvs'],encoding='utf8')
+ if len(json_bananas) < len( os.listdir("encrypted_received_image_snaps") ):
+ print "There are less keys than snaps, some snaps won't be able to be decrypted"
+ for file_name in os.listdir("encrypted_received_image_snaps"):
+ could_decrypt = False
+ for snap_pair in json_bananas:
+ (key,iv) = extract_key_and_iv( json_bananas[snap_pair] )
+
+ s = run_get_output('openssl aes-128-cbc -K %s -iv %s -d -in encrypted_received_image_snaps/%s -out decrypted_received_image_snaps/%s' %(key,iv,file_name,file_name))
+ if s == '':
+ could_decrypt = True
+ break
+ #no error then the image was decoded properly
+ if not could_decrypt:
+ print "The image %s could not be decrypted, none of the keys in the bananas file worked" %file_name
+ #break when decrypt work
+
+def decrypt_file(in_file, out_file, cipher):
+ bs = AES.block_size
+ next_chunk = ''
+ finished = False
+ while not finished:
+ chunk, next_chunk = next_chunk, cipher.decrypt(in_file.read(1024 * bs))
+ if len(next_chunk) == 0:
+ padding_length = ord(chunk[-1])
+ chunk = chunk[:-padding_length]
+ finished = True
+ out_file.write(chunk)
+
+if __name__ == '__main__':
+ global VERSION
+ VERSION = get_version()
+ #stop the application to save the 'bananas file'
+ run_blocking_cmd('adb shell am force-stop com.snapchat.android')
+ pull_images()
+ pull_bananas_cache_file()
+ decrypt_bananas_file()
+ decrypt_images()
+ #Cleaning up
+ run_blocking_cmd('rm encrypted_bananas_file decrypted_bananas_file')
+ run_blocking_cmd('rm -r encrypted_received_image_snaps')
diff --git a/devtools.js b/devtools.js
new file mode 100644
index 0000000..ef489a2
--- /dev/null
+++ b/devtools.js
@@ -0,0 +1,10 @@
+navigator.userAgent.indexOf('Firefox') != -1 &&
+ browser.devtools.panels.create('HackTools', 'get_started16.png', 'index.html');
+
+navigator.userAgent.indexOf('Chrome') != -1 &&
+ chrome.devtools.panels.create(
+ 'HackTools', // title for the panel tab
+ null, // path to an icon
+ 'index.html', // html page which is gonna be injecting into the tab's content
+ null // callback function here
+ );
diff --git a/devtools.json b/devtools.json
new file mode 100644
index 0000000..47b0098
--- /dev/null
+++ b/devtools.json
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/index.html.txt b/index.html.txt
new file mode 100644
index 0000000..80d60b9
--- /dev/null
+++ b/index.html.txt
@@ -0,0 +1,139 @@
+
+
+
+
+
+
+