Scapy module

Author: hatscode

Generic programming/Class work/revision.py

@@ -0,0 +1,52 @@
+
+
+my_string = "Hello world, My name is Alex"
+
+new_string = my_string.split(" ")
+
+words = []
+
+for word in new_string:
+    word.strip(",.?!")
+    words.append(word)
+
+print(", ".join(words))
+
+
+print("I love python"[10])
+
+# Using the find method
+
+print(my_string.find("name"))
+print(my_string.find("H"))
+print(my_string.rfind("16"))
+
+
+# Negative indeces
+python = "Python"
+
+print(python)
+
+print(python[-5:4])
+print(python[-5:-2])
+
+# String concantenation
+
+print("Hello" + " World")
+print("ha" * 3)
+
+greet = "Hellllo"
+
+print(greet.count("l"))
+
+
+# Relational operators
+
+print(10<10.5)
+
+# print(3 < "10") Values of different types cannot be compared
+
+print("Dog" > "dog")
+
+print("fun" in "refunded")
+

Projects/main.py

@@ -0,0 +1,72 @@
+from kivy.app import App
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.label import Label
+from kivy.uix.button import Button
+from kivy.graphics import Color, Rectangle
+import random
+
+# List of quotes
+quotes = [
+    "The only way to do great work is to love what you do. — Steve Jobs",
+    "Success is not the key to happiness. Happiness is the key to success. — Albert Schweitzer",
+    "Your time is limited, don’t waste it living someone else’s life. — Steve Jobs",
+    "The best way to predict the future is to create it. — Peter Drucker",
+    "It does not matter how slowly you go as long as you do not stop. — Confucius",
+    "You miss 100% of the shots you don’t take. — Wayne Gretzky",
+    "Believe you can and you’re halfway there. — Theodore Roosevelt",
+    "The only limit to our realization of tomorrow will be our doubts of today. — Franklin D. Roosevelt",
+    "Act as if what you do makes a difference. It does. — William James",
+    "Success usually comes to those who are too busy to be looking for it. — Henry David Thoreau"
+]
+
+class QuoteGeneratorApp(App):
+    def build(self):
+        self.title = 'Random Quote Generator'
+        
+        layout = BoxLayout(orientation='vertical', padding=10, spacing=10)
+
+        # Set a background color for the layout
+        with layout.canvas.before:
+            Color(1, 0.9, 0.5, 1)  # Light yellow background
+            self.rect = Rectangle(size=layout.size, pos=layout.pos)
+
+        layout.bind(size=self.update_rect, pos=self.update_rect)
+
+        # Label to display the quote
+        self.quote_label = Label(text="", size_hint=(1, 0.8), text_size=(400, None),
+                                 halign='center', valign='middle', color=(10, 0.5, 0, 1))  # Green text
+        self.quote_label.bind(size=self.update_text_size)  # Bind size to update text size
+        layout.add_widget(self.quote_label)
+
+        # Button to get a new quote
+        quote_button = Button(text='Get Random Quote', size_hint=(1, 0.2))
+        quote_button.bind(on_press=self.get_random_quote)
+        
+        # Set button background color
+        with quote_button.canvas.before:
+            Color(1, 0.65, 0, 1)  # Orange background
+            self.btn_rect = Rectangle(size=quote_button.size, pos=quote_button.pos)
+
+        quote_button.bind(size=self.update_button_rect, pos=self.update_button_rect)
+        layout.add_widget(quote_button)
+
+        return layout
+
+    def update_text_size(self, *args):
+        # Update the text size to allow for wrapping
+        self.quote_label.text_size = (self.quote_label.width, None)
+
+    def get_random_quote(self, instance):
+        random_quote = random.choice(quotes)
+        self.quote_label.text = random_quote
+
+    def update_rect(self, instance, value):
+        self.rect.size = instance.size
+        self.rect.pos = instance.pos
+
+    def update_button_rect(self, instance, value):
+        self.btn_rect.size = instance.size
+        self.btn_rect.pos = instance.pos
+
+if __name__ == '__main__':
+    QuoteGeneratorApp().run()

Socket Programming/__pycache__/socket.cpython-312.pyc

@@ -0,0 +1,26 @@
+from scapy.all import *
+
+def tcp_syn_scan(target, ports):
+    print(f"Scanning {target} for open TCP ports...")
+    for port in ports:
+        src_port = RandShort()
+        resp = sr1(IP(dst=target)/TCP(sport=src_port, dport=port, flags="S"), timeout=1, verbose=0)
+        
+        if resp is None:
+            print(f"Port {port}: Filtered")
+        elif resp.haslayer(TCP):
+            if resp.getlayer(TCP).flags == 0x12:  # SYN-ACK
+                # Send RST to gracefully close the connection
+                sr(IP(dst=target)/TCP(sport=src_port, dport=port, flags="R"), timeout=1, verbose=0)
+                print(f"Port {port}: Open")
+            elif resp.getlayer(TCP).flags == 0x14:  # RST-ACK
+                print(f"Port {port}: Closed")
+        elif resp.haslayer(ICMP):
+            icmp_layer = resp.getlayer(ICMP)
+            if int(icmp_layer.type) == 3 and int(icmp_layer.code) in [1, 2, 3, 9, 10, 13]:
+                print(f"Port {port}: Filtered")
+
+# Example usage
+target = "127.0.0.1"
+ports = [21, 22, 80, 443, 3389]
+tcp_syn_scan(target, ports)

Socket Programming/hack.py

@@ -3,5 +3,4 @@
 
 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
-
 print(s)

Socket Programming/sockets.py

@@ -0,0 +1 @@
+pip

venv/Lib/site-packages/Automat-24.8.1.dist-info/INSTALLER

@@ -0,0 +1,21 @@
+Copyright (c) 2014
+Rackspace
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

venv/Lib/site-packages/Automat-24.8.1.dist-info/LICENSE

@@ -0,0 +1,199 @@
+Metadata-Version: 2.1
+Name: Automat
+Version: 24.8.1
+Summary: Self-service finite-state machines for the programmer on the go.
+Author-email: Glyph <[email protected]>
+License: Copyright (c) 2014
+        Rackspace
+        
+        Permission is hereby granted, free of charge, to any person obtaining
+        a copy of this software and associated documentation files (the
+        "Software"), to deal in the Software without restriction, including
+        without limitation the rights to use, copy, modify, merge, publish,
+        distribute, sublicense, and/or sell copies of the Software, and to
+        permit persons to whom the Software is furnished to do so, subject to
+        the following conditions:
+        
+        The above copyright notice and this permission notice shall be
+        included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+        LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+        OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+        WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Documentation, https://automat.readthedocs.io/
+Project-URL: Source, https://github.com/glyph/automat/
+Keywords: fsm,state machine,automata
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing-extensions; python_version < "3.10"
+Provides-Extra: visualize
+Requires-Dist: graphviz>0.5.1; extra == "visualize"
+Requires-Dist: Twisted>=16.1.1; extra == "visualize"
+
+# Automat #
+
+[![Documentation Status](https://readthedocs.org/projects/automat/badge/?version=latest)](http://automat.readthedocs.io/en/latest/)
+[![Build Status](https://github.com/glyph/automat/actions/workflows/ci.yml/badge.svg?branch=trunk)](https://github.com/glyph/automat/actions/workflows/ci.yml?query=branch%3Atrunk)
+[![Coverage Status](http://codecov.io/github/glyph/automat/coverage.svg?branch=trunk)](http://codecov.io/github/glyph/automat?branch=trunk)
+
+## Self-service finite-state machines for the programmer on the go. ##
+
+Automat is a library for concise, idiomatic Python expression of finite-state
+automata (particularly deterministic finite-state transducers).
+
+Read more here, or on [Read the Docs](https://automat.readthedocs.io/), or watch the following videos for an overview and presentation
+
+### Why use state machines? ###
+
+Sometimes you have to create an object whose behavior varies with its state,
+but still wishes to present a consistent interface to its callers.
+
+For example, let's say you're writing the software for a coffee machine.  It
+has a lid that can be opened or closed, a chamber for water, a chamber for
+coffee beans, and a button for "brew".
+
+There are a number of possible states for the coffee machine.  It might or
+might not have water.  It might or might not have beans.  The lid might be open
+or closed.  The "brew" button should only actually attempt to brew coffee in
+one of these configurations, and the "open lid" button should only work if the
+coffee is not, in fact, brewing.
+
+With diligence and attention to detail, you can implement this correctly using
+a collection of attributes on an object; `hasWater`, `hasBeans`, `isLidOpen`
+and so on.  However, you have to keep all these attributes consistent.  As the
+coffee maker becomes more complex - perhaps you add an additional chamber for
+flavorings so you can make hazelnut coffee, for example - you have to keep
+adding more and more checks and more and more reasoning about which
+combinations of states are allowed.
+
+Rather than adding tedious `if` checks to every single method to make sure that
+each of these flags are exactly what you expect, you can use a state machine to
+ensure that if your code runs at all, it will be run with all the required
+values initialized, because they have to be called in the order you declare
+them.
+
+You can read about state machines and their advantages for Python programmers
+in more detail [in this excellent article by Jean-Paul
+Calderone](https://web.archive.org/web/20160507053658/https://clusterhq.com/2013/12/05/what-is-a-state-machine/).
+
+### What makes Automat different? ###
+
+There are
+[dozens of libraries on PyPI implementing state machines](https://pypi.org/search/?q=finite+state+machine).
+So it behooves me to say why yet another one would be a good idea.
+
+Automat is designed around this principle: while organizing your code around
+state machines is a good idea, your callers don't, and shouldn't have to, care
+that you've done so.  In Python, the "input" to a stateful system is a method
+call; the "output" may be a method call, if you need to invoke a side effect,
+or a return value, if you are just performing a computation in memory.  Most
+other state-machine libraries require you to explicitly create an input object,
+provide that object to a generic "input" method, and then receive results,
+sometimes in terms of that library's interfaces and sometimes in terms of
+classes you define yourself.
+
+For example, a snippet of the coffee-machine example above might be implemented
+as follows in naive Python:
+
+```python
+class CoffeeMachine(object):
+    def brewButton(self) -> None:
+        if self.hasWater and self.hasBeans and not self.isLidOpen:
+            self.heatTheHeatingElement()
+            # ...
+```
+
+With Automat, you'd begin with a `typing.Protocol` that describes all of your
+inputs:
+
+```python
+from typing import Protocol
+
+class CoffeeBrewer(Protocol):
+    def brewButton(self) -> None:
+        "The user pressed the 'brew' button."
+    def putInBeans(self) -> None:
+        "The user put in some beans."
+```
+
+We'll then need a concrete class to contain the shared core of state shared
+among the different states:
+
+```python
+from dataclasses import dataclass
+
+@dataclass
+class BrewerCore:
+    heatingElement: HeatingElement
+```
+
+Next, we need to describe our state machine, including all of our states.  For
+simplicity's sake let's say that the only two states are `noBeans` and
+`haveBeans`:
+
+```python
+from automat import TypeMachineBuilder
+
+builder = TypeMachineBuilder(CoffeeBrewer, BrewerCore)
+noBeans = builder.state("noBeans")
+haveBeans = builder.state("haveBeans")
+```
+
+Next we can describe a simple transition; when we put in beans, we move to the
+`haveBeans` state, with no other behavior.
+
+```python
+# When we don't have beans, upon putting in beans, we will then have beans
+noBeans.upon(CoffeeBrewer.putInBeans).to(haveBeans).returns(None)
+```
+
+And then another transition that we describe with a decorator, one that *does*
+have some behavior, that needs to heat up the heating element to brew the
+coffee:
+
+```python
+@haveBeans.upon(CoffeeBrewer.brewButton).to(noBeans)
+def heatUp(inputs: CoffeeBrewer, core: BrewerCore) -> None:
+    """
+    When we have beans, upon pressing the brew button, we will then not have
+    beans any more (as they have been entered into the brewing chamber) and
+    our output will be heating the heating element.
+    """
+    print("Brewing the coffee...")
+    core.heatingElement.turnOn()
+```
+
+Then we finalize the state machine by building it, which gives us a callable
+that takes a `BrewerCore` and returns a synthetic `CoffeeBrewer`
+
+```python
+newCoffeeMachine = builder.build()
+```
+
+```python
+>>> coffee = newCoffeeMachine(BrewerCore(HeatingElement()))
+>>> machine.putInBeans()
+>>> machine.brewButton()
+Brewing the coffee...
+```
+
+All of the *inputs* are provided by calling them like methods, all of the
+*output behaviors* are automatically invoked when they are produced according
+to the outputs specified to `upon` and all of the states are simply opaque
+tokens.