在 GGLua 中实现 SHA1 加密算法的代码比较复杂，因为 SHA1 是一个较为复杂的哈希函数，涉及到许多位操作、填充和压缩步骤。下面是一个简单的实现，尽管它可能不如专业库中的实现高效或安全，但可以作为学习和实验的基础。

以下是一个基本的 SHA1 实现，使用 Lua 的标准库（不借助任何外部库）：

```lua
local function rol(n, b)
    return ((n << b) | (n >> (32 - b))) & 0xFFFFFFFF
end

local function sha1(msg)
    local h = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 }
    
    -- 预处理步骤
    local original_byte_len = #msg
    msg = msg .. string.char(0x80)  -- 添加一个 '1' 位
    while #msg % 64 ~= 56 do
        msg = msg .. string.char(0x00)  -- 填充 '0' 位
    end
    
    -- 添加原始消息长度
    msg = msg .. string.pack(">I8", original_byte_len * 8)

    for i = 1, #msg, 64 do
        local chunk = msg:sub(i, i + 63)
        local w = {}
        
        for j = 1, 16 do
            w[j - 1] = string.unpack(">I4", chunk:sub((j - 1) * 4 + 1, j * 4))
        end
        
        for j = 16, 79 do
            w[j] = rol(w[j - 3] ~ w[j - 8] ~ w[j - 14] ~ w[j - 16], 1)
        end
        
        local a, b, c, d, e = table.unpack(h)

        for j = 0, 79 do
            local f, k

            if j < 20 then
                f = (b & c) | (~b & d)
                k = 0x5A827999
            elseif j < 40 then
                f = b ~ c ~ d
                k = 0x6ED9EBA1
            elseif j < 60 then
                f = (b & c) | (b & d) | (c & d)
                k = 0x8F1BBCDC
            else
                f = b ~ c ~ d
                k = 0xCA62C1D6
            end

            local temp = rol(a, 5) + f + e + k + w[j] & 0xFFFFFFFF
            e = d
            d = c
            c = rol(b, 30)
            b = a
            a = temp
        end

        h[1] = (h[1] + a) & 0xFFFFFFFF
        h[2] = (h[2] + b) & 0xFFFFFFFF
        h[3] = (h[3] + c) & 0xFFFFFFFF
        h[4] = (h[4] + d) & 0xFFFFFFFF
        h[5] = (h[5] + e) & 0xFFFFFFFF
    end

    return string.format("%08X%08X%08X%08X%08X", h[1], h[2], h[3], h[4], h[5])
end

-- 示例使用
local input = "Hello, World!"
local hash = sha1(input)
print(hash)  -- 输出 SHA1 哈希
```

这个实现包括了 SHA1 的预处理、消息扩展和主循环处理。请注意，SHA1 被认为不再安全，因此在生产环境中应使用更安全的哈希算法（例如 SHA-256）。