函数概念与极限

Posted on 2024-07-29 Edited on 2024-12-15 In math Word count in article: 1.3k Reading time ≈ 5 mins.

高数笔记

OSINT

Posted on 2024-07-11 Edited on 2024-08-02 In ctf Word count in article: 235 Reading time ≈ 1 mins.

OSINT

search

https://www.google.com/advanced_search
https://yandex.com/
https://tineye.com/

fakenamegenerator

https://www.fakenamegenerator.com/

exiftool

https://onlineexifviewer.com/

satellite image

https://www.google.com/maps/@37.4219999,-122.0840575,3a,75y,35.56h,90t/data=!3m6!1e1!3m4!1sAFQjCNGR9Z5wZj4Y6h8q8zQ5hZ1Zl7q6Q!2e0!7i13312!8i6656

geoguessr tips

https://somerandomstuff1.wordpress.com/2019/02/08/geoguessr-the-top-tips-tricks-and-techniques/

email

https://phonebook.cz
https://www.voilanorbert.com/
clearbit connect
email checker
- https://email-checker.net/check

domain

https://www.whois.com/whois/

data breach

https://dehashed.com/
https://weleakinfo.io/
https://namechk.com
https://whatsmyname.app/?trk=article-ssr-frontend-pulse_little-text-block
https://www.whitepages.com/
https://www.truepeoplesearch.com/
https://webmii.com/
https://thatsthem.com/
https://www.spokeo.com/
https://voterrecords.com/

hash decrypt

https://hashes.com/en/decrypt/hash

phone

https://www.truecaller.com/
https://calleridtest.com/

twitter search advanced

https://twitter.com/search-advanced
https://www.tweetbinder.com/blog/twitter-geocode/
https://thoughtfaucet.com/search-twitter-by-location/examples/
- From the url
- Entering the search string below let’s you use twitter location search to see their tweets:
- geocode:38.890550,-77.009017,.02km
- The above string will give you Tweets in a 0.02km radius around the Capitol. You can expand or shrink the geofence however you like however you like. But if you want to search Twitter for a specific date range, for example, 1/6/2021, you’ll need to add that as well:
- geocode:38.890550,-77.009017,.02km
- since:2021-01-05 until:2021-01-07

twitter tool

xPro pay to use
api change

maybe useful

OSINT Framework

https://osintframework.com/ ### integration tool
https://www.aware-online.com/en/ ### long-tail keyword
https://keywordtool.io/

proxy

Posted on 2024-07-09 Word count in article: 415 Reading time ≈ 2 mins.

网络分层模型

OSI模型（Open Systems Interconnection model），该模型分为7层：

物理层（Physical Layer）
数据链路层（Data Link Layer）
网络层（Network Layer）
传输层（Transport Layer）
会话层（Session Layer）
表示层（Presentation Layer）
应用层（Application Layer）

tap: 属于数据链路层（第2层）。tap设备用于在以太网帧级别操作。
tun, vpn: 属于网络层（第3层）。tun设备用于IP包级别操作，VPN通常工作在第3层（网络层）。
icmp: 属于网络层（第3层）。ICMP（Internet Control Message Protocol）用于网络设备间的控制信息传递，如ping命令。

in short

- **tap**: 2层（数据链路层）
- **tun, vpn**: 3层（网络层）
- **icmp**: 3层（网络层）
- **TCP/UDP**: 4层（传输层）
- **socks**: 7层（应用层）建立连接和传输数据时也涉及传输层（第4层）
- **system proxy (clash default)**: 7层（应用层）no ICMP
- **proxychains**: 7层（应用层）no ICMP
- **HTTP/HTTPS、FTP、SMTP**: 7层（应用层）
- **SSH**: 7层（应用层）使用传输层协议（通常是 TCP）22 port

tips:

SOCKS4:支持基本的 TCP 流量转发，不支持 UDP。
SOCKS5:扩展了 SOCKS4 的功能，增加了对 UDP 流量的支持，并且提供了更强的认证和安全特性。
proxychains 是一个工具，它会拦截应用程序的网络连接，并通过代理服务器转发这些连接。它通常用于让应用程序通过 SOCKS 或 HTTP 代理连接到网络。由于 proxychains 操作的是应用程序层的流量，并且修改传输层的连接请求，它应归类为应用层（第7层），尽管操作涉及传输层（第4层）的连接。

proxysetting

Posted on 2024-02-08 Edited on 2024-08-02 In network Word count in article: 314 Reading time ≈ 1 mins.

Configuring Proxy Settings

In the development world, setting up a proxy is a common task, especially when working behind a corporate firewall or when you want to ensure secure and private browsing. Proxies act as intermediaries between your computer and the internet, helping in filtering requests, improving security, and managing network traffic more efficiently.

NPM

Setting up Proxy in NPM

To configure npm to use a proxy, you can use the npm config set command as follows:

1 2	npm config set proxy "http://localhost:7890" npm config set https-proxy "http://localhost:7890"

Here, http://localhost:7890 is the address of your proxy server. Change it according to your proxy server's IP address and port number.

Removing Proxy Configuration

If you need to remove the proxy configuration, for instance, when you're not behind a proxy anymore, you can use the npm config delete command:

1 2	npm config delete proxy npm config delete https-proxy

Linux Shell Proxy Configuration

Setting up Proxy

You can set proxy environment variables in the shell as follows:

1 2	export http_proxy="http://localhost:7890" export https_proxy="https://localhost:7890"

Replace localhost:7890 with your proxy server's IP address and port. Note the difference in the protocol (http vs. https) for http_proxy and https_proxy.

Removing Proxy Configuration

To revert the changes or to disable the use of a proxy, you can unset these environment variables:

1 2	unset http_proxy unset https_proxy

Pip Proxy Configuration

Using Proxy with Pip

1	pip --proxy http://localhost:7890 install somepackage

Replace http://localhost:7890 with your proxy's URL. Append the name of the package you wish to install instead of somepackage.

git

1 2	git config --global http.proxy http://127.0.0.1:7890 git config --global https.proxy https://127.0.0.1:7890

1 2	git config --global http.https://github.com.proxy http://127.0.0.1:7890 git config --global https.https://github.com.proxy https://127.0.0.1:7890

1
2
3

git config --global --unset http.proxy
git config --global --unset https.proxy

unfinished

ctfnoob01-换行符

Posted on 2024-02-05 Edited on 2024-08-02 In ctf Word count in article: 565 Reading time ≈ 2 mins.

跨平台换行符差异导致的密码破解失败

在进行密码破解任务时，我遇到了一个典型但容易被忽视的问题：不同操作系统间的换行符差异。在这篇博客中，我将分享我的经验和解决方案，希望能帮助那些可能面临同样挑战的人。

背景

在 Windows 系统上生成了一个用于密码破解的字典文件，文件中的换行符遵循 Windows 的标准，即 CRLF (\r\n)。然而，我的破解工具运行在 WSL 环境中，该环境以及大多数 Linux 工具期望的换行符是 LF (\n)。

我确定字典中有正确密码。当使用 VSCode 的 WSL 终端运行如下fcrackzip命令时，破解尝试失败了

1	fcrackzip -D -p ./vspro/passwords.txt -u flag.zip

通过file命令检查字典文件，确认了问题所在：

1 2	➜ code file ./vspro/passwords.txt ./vspro/passwords.txt: ASCII text, with CRLF line terminators

这表明文件是用 CRLF 作为换行符的，而不是 WSL 和 Linux 工具期望的 LF

解决方案

`If conditions permit`

在 linux 环境中使用脚本生成字典。

`Else` 使用指令转换换行符

为了解决这个问题，我需要将字典文件中的 CRLF 换行符转换为LF。Linux和WSL提供了一个非常方便的工具dos2unix，它可以实现这种转换。

1	sudo apt update && sudo apt install dos2unix

安装完成后，使用dos2unix命令转换文件：

1	dos2unix ./vspro/passwords.txt

验证转换

转换完成后，再次使用file命令验证文件的换行符：

1 2	➜ code file ./vspro/passwords.txt ./vspro/passwords.txt: ASCII text

这次，文件描述不再提到CRLF换行符，说明转换成功。

重新尝试破解

转换换行符后，我再次运行了fcrackzip命令，这次成功破解了ZIP文件的密码。

end

This experience highlights that, when working across different platforms, even minor details like line breaks can lead to significant obstacles. Despite their seeming insignificance, these differences can greatly impact how files are processed and texts are parsed. Thankfully, with the use of straightforward tools and commands, these issues can be easily overcome, allowing for a seamless workflow.

I hope this blog post assists those facing similar challenges in cross-platform tasks, such as password cracking or any activity involving text file processing. Remember, when you come across unusual issues, it's worth starting with the basics, like the seemingly trivial matter of line breaks.

Structural

Posted on 2024-02-01 Edited on 2024-08-06 In Design Patterns Word count in article: 576 Reading time ≈ 2 mins.

结构型模式

组合类和对象以形成更大的结构
简化结构中的关系，使系统更易于理解和扩展。
减少系统中不同部分之间的依赖关系，提高系统的灵活性和可维护性。

结构型模式主要包括以下几种：

适配器模式（Adapter）：允许将一个类的接口转换成客户端期望的另一个接口，使原本接口不兼容的类可以一起工作。
桥接模式（Bridge）：将抽象部分与实现部分分离，使它们可以独立变化，通过组合的方式建立两者之间的联系，而不是继承。
组合模式（Composite）：允许将对象组合成树形结构以表示“部分-整体”的层次结构。使得用户对单个对象和组合对象的使用具有一致性。
装饰器模式（Decorator）：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式相比生成子类更为灵活。
外观模式（Facade）：提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。
享元模式（Flyweight）：运用共享技术有效地支持大量细粒度的对象，以减少创建对象的数量，降低程序内存的占用，提高效率。
代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问，可以在客户端和目标对象之间起到中介的作用，并可以添加一些功能。

这些模式在不同的应用场景中有着广泛的应用，比如在系统需要使用现有的类但其接口不符合系统的需要时，可以使用适配器模式来进行接口适配；当系统需要对一系列的对象进行操作而不想关心这些对象是简单的还是复杂的组合时，可以使用组合模式来统一对待。

通过运用结构型模式，开发者可以更容易地设计出结构清晰、关系简单、高效灵活的系统架构。

创建型模式

Posted on 2024-02-01 Edited on 2024-08-02 In Design Patterns Word count in article: 2k Reading time ≈ 7 mins.

创建型模式 `Creational` `Patterns`

创建型模式关注如何创建对象，将对象的实例化和声明相分离。
关注于对象的创建过程，目的是将对象的实例化与客户端的使用分离。
通过这种方式，系统中的具体类的实例化不会使代码变得僵硬，增加了系统的灵活性和可维护性。
更有效地封装和抽象化对象的创建过程。

创建型模式包括：

单例模式（Singleton）：确保一个类只有一个实例，并提供一个全局访问点。
工厂方法模式（Factory Method）：定义一个创建对象的接口，让子类决定实例化哪一个类。
抽象工厂模式（Abstract Factory）：提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。
建造者模式（Builder）：使用多个简单的对象一步一步构建成一个复杂的对象。
原型模式（Prototype）：通过复制现有的实例来创建新的实例，而不是通过新建实例。

单例模式

保证一个类只有一个实例，并提供一个访问该实例的全局节点。

懒汉式双重校验锁（DCL，即 double-checked locking）

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

volatile: 这是 Java 语言的一个关键字，用于指示 JVM（Java 虚拟机），这个变量可能会被多个线程同时访问和修改，但是它不会被线程缓存（每次访问变量时都要从主内存中读取），并且每次修改都会立即写入主内存。这个关键字的主要作用是确保变量的可见性和防止指令重排序优化，这对于多线程环境下安全创建单例至关重要。

工厂方法模式

在父类中提供一个创建对象的方法，允许子类决定实例化对象的类型。
如果无法预知对象确切类别及其依赖关系时，可使用工厂方法。
如果你希望用户能扩展你软件库或框架的内部组件，可使用工厂方法。
如果你希望复用现有对象来节省系统资源，而不是每次都重新创建对象，可使用工厂方法。

public interface Shape {
   void draw();
}
////////////////////////////////
public class Rectangle implements Shape {
   @Override
   public void draw() {
      System.out.println();
   }
}
//////////////
public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if ...
      return null;
   }
}

抽象工厂模式

创建一系列相关的对象
无需指定其具体类。
其他工厂的工厂。

//定义抽象工厂

public interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// 接着，定义 Button 和 Checkbox 接口：

public interface Button {
    void paint();
}

public interface Checkbox {
    void paint();
}

// 然后，实现具体的工厂类 WinFactory 和 MacFactory：

public class WinFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WinButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new WinCheckbox();
    }
}

public class MacFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

// 定义具体产品类 WinButton, WinCheckbox, MacButton, 和 MacCheckbox：

public class WinButton implements Button {
    @Override
    public void paint() {
        System.out.println("Rendering a button in Windows style.");
    }
}

public class MacButton implements Button {
    @Override
    public void paint() {
        System.out.println("Rendering a button in macOS style.");
    }
}

public class WinCheckbox implements Checkbox {
    @Override
    public void paint() {
        System.out.println("Rendering a checkbox in Windows style.");
    }
}

public class MacCheckbox implements Checkbox {
    @Override
    public void paint() {
        System.out.println("Rendering a checkbox in macOS style.");
    }
}

// 最后，实现客户端代码 Application 和 ApplicationConfigurator：

public class Application {
    private GUIFactory factory;
    private Button button;

    public Application(GUIFactory factory) {
        this.factory = factory;
    }

    public void createUI() {
        this.button = factory.createButton();
    }

    public void paint() {
        button.paint();
    }
}

public class ApplicationConfigurator {
    public static void main(String[] args) {
        GUIFactory factory;
        String OS = System.getProperty("os.name");
        
        if (OS.contains("Windows")) {
            factory = new WinFactory();
        } else if (OS.contains("Mac")) {
            factory = new MacFactory();
        } else {
            throw new RuntimeException("Error! Unknown operating system.");
        }

        Application app = new Application(factory);
        app.createUI();
        app.paint();
    }
}

这段 Java 代码完整实现了抽象工厂模式，包括抽象工厂接口、具体工厂类、抽象产品接口、具体产品类以及客户端代码。客户端代码仅依赖于抽象类型（GUIFactory、Button 和 Checkbox），使得你可以在不修改客户端代码的情况下引入新的工厂或产品变体。

建造者模式

AKA生成器模式
分步骤创建复杂对象
使用相同的创建代码生成不同类型和形式的对象。
链式编程
只有当产品较为复杂且需要详细配置时，使用生成器模式才有意义。

public class Car {
    // 假设这里有一些属性和方法来表示汽车的各种特性
}

public class Manual {
    // 假设这里有一些属性和方法来表示手册的各种特性
}

// 接下来是 `Builder` 接口的定义，包括创建产品对象不同部件的方法：

public interface Builder {
    void reset();
    void setSeats(int number);
    void setEngine(String engine);
    void setTripComputer(boolean present);
    void setGPS(boolean present);
}

// 然后，我们实现具体的生成器类 `CarBuilder` 和 `CarManualBuilder`：

public class CarBuilder implements Builder {
    private Car car;

    public CarBuilder() {
        this.reset();
    }

    @Override
    public void reset() {
        this.car = new Car();
    }

    @Override
    public void setSeats(int number) {
        // 实现设置座位数的逻辑
    }

    @Override
    public void setEngine(String engine) {
        // 实现设置引擎的逻辑
    }

    @Override
    public void setTripComputer(boolean present) {
        // 实现设置行车电脑的逻辑
    }

    @Override
    public void setGPS(boolean present) {
        // 实现设置GPS的逻辑
    }

    public Car getProduct() {
        Car product = this.car;
        this.reset();
        return product;
    }
}

public class CarManualBuilder implements Builder {
    private Manual manual;

    public CarManualBuilder() {
        this.reset();
    }

    @Override
    public void reset() {
        this.manual = new Manual();
    }

    @Override
    public void setSeats(int number) {
        // 实现添加关于座椅的文档逻辑
    }

    @Override
    public void setEngine(String engine) {
        // 实现添加关于引擎的介绍逻辑
    }

    @Override
    public void setTripComputer(boolean present) {
        // 实现添加关于行车电脑的介绍逻辑
    }

    @Override
    public void setGPS(boolean present) {
        // 实现添加关于GPS的介绍逻辑
    }

    public Manual getProduct() {
        Manual product = this.manual;
        this.reset();
        return product;
    }
}

// 接着，实现 `Director` 类，它负责定义构建过程的不同步骤：

public class Director {
    public void constructSportsCar(Builder builder) {
        builder.reset();
        builder.setSeats(2);
        builder.setEngine("SportEngine");
        builder.setTripComputer(true);
        builder.setGPS(true);
    }

    // 这里可以添加更多的方法来构建不同类型的汽车
}

// 最后是客户端代码，它演示了如何使用这些类来构建产品：

public class Application {
    public static void main(String[] args) {
        Director director = new Director();

        CarBuilder carBuilder = new CarBuilder();
        director.constructSportsCar(carBuilder);
        Car car = carBuilder.getProduct();

        CarManualBuilder manualBuilder = new CarManualBuilder();
        director.constructSportsCar(manualBuilder);
        Manual manual = manualBuilder.getProduct();

        // 在这里，car 和 manual 是根据相同的构建过程创建的，
        // 但它们是完全不同的产品。
    }
}

这段 Java 代码展示了如何实现生成器模式，其中包括创建复杂对象的过程，使得最终产品的构建与其表示分离，允许相同的构建过程创建不同的表示。

原型模式

复制已有对象
当直接创建对象的代价比较大时，则采用这种模式。
Java 中，原型模式通常通过实现 Cloneable 接口并重写 Object 类的 clone() 方法来实现。

import java.util.HashMap;
import java.util.Map;

// 抽象类实现 Cloneable 接口
abstract class Shape implements Cloneable {
    private String id;
    protected String type;

    abstract void draw();

    public String getType() {
        return type;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

// 具体的形状类
class Rectangle extends Shape {
    public Rectangle() {
        type = "Rectangle";
    }

    @Override
    void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

class Circle extends Shape {
    public Circle() {
        type = "Circle";
    }

    @Override
    void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

// 缓存类
class ShapeCache {
    private static Map<String, Shape> shapeMap = new HashMap<>();

    public static Shape getShape(String shapeId) {
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape) cachedShape.clone();
    }

    public static void loadCache() {
        Circle circle = new Circle();
        circle.setId("1");
        shapeMap.put(circle.getId(), circle);

        Rectangle rectangle = new Rectangle();
        rectangle.setId("2");
        shapeMap.put(rectangle.getId(), rectangle);
    }
}

// 客户端代码
public class PrototypePatternDemo {
    public static void main(String[] args) {
        ShapeCache.loadCache();

        Shape clonedShape1 = ShapeCache.getShape("1");
        System.out.println("Shape : " + clonedShape1.getType());

        Shape clonedShape2 = ShapeCache.getShape("2");
        System.out.println("Shape : " + clonedShape2.getType());
    }
}

这段代码展示了原型设计模式的核心：通过克隆现有对象来创建新对象，从而避免了通过 new 关键字创建对象带来的成本。这里，Shape 抽象类实现了 Cloneable 接口，允许其子类 Rectangle 和 Circle 被克隆。ShapeCache 类用于预存储和克隆形状对象，而客户端代码演示了如何从缓存中获取并使用这些克隆对象。

end

设计模式

Posted on 2024-02-01 Edited on 2024-08-02 In Design Patterns Word count in article: 305 Reading time ≈ 1 mins.

设计模式原则

设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

1、开闭原则 Open Close Principle

对扩展开放，对修改关闭。
使程序的扩展性好，易于维护和升级。
需要使用接口和抽象类

2、里氏代换原则Liskov Substitution Principle

任何基类可以出现的地方，子类一定可以出现。
里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则Dependence Inversion Principle

针对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则Interface Segregation Principle

使用多个隔离的接口，比使用单个接口要好。
降低类之间的耦合度。

5、迪米特法则，又称最少知道原则Demeter Principle

一个实体应当尽量少地与其他实体之间发生相互作用。

6、合成复用原则Composite Reuse Principle

尽量使用合成/聚合的方式，而不是使用继承。

类型

23 种设计模式。
创建型模式Creational Patterns
结构型模式Structural Patterns
行为型模式Behavioral Patterns。

OSINT

search

fakenamegenerator

exiftool

satellite image

geoguessr tips

email

domain

data breach

hash decrypt

phone

twitter search advanced

twitter tool

maybe useful

OSINT Framework

网络分层模型

in short

tips:

Configuring Proxy Settings

NPM

Setting up Proxy in NPM

Removing Proxy Configuration

Linux Shell Proxy Configuration

Setting up Proxy

Removing Proxy Configuration

Pip Proxy Configuration

Using Proxy with Pip

git

unfinished

跨平台换行符差异导致的密码破解失败

背景

解决方案

If conditions permit

Else 使用指令转换换行符

验证转换

重新尝试破解

end

结构型模式

创建型模式 Creational Patterns

单例模式

工厂方法模式

抽象工厂模式

建造者模式

原型模式

end

设计模式原则

类型

`If conditions permit`

`Else` 使用指令转换换行符

创建型模式 `Creational` `Patterns`