Fully statically linked for both x64 and arm64. Updated build.sh to always compile both versions
This commit is contained in:
parent
ae4aa7cf80
commit
d257ae49f1
|
|
@ -0,0 +1,91 @@
|
|||
# ARM64 Cross-Compilation Implementation Summary
|
||||
|
||||
## What Was Implemented
|
||||
|
||||
✅ **Complete ARM64 static linking support** for nostr_core_lib with secp256k1 bundled internally.
|
||||
|
||||
## Key Changes Made
|
||||
|
||||
### 1. Makefile Enhancements
|
||||
- Added ARM64 secp256k1 library paths (`SECP256K1_ARM64_LIB`, `SECP256K1_ARM64_PRECOMPUTED_LIB`)
|
||||
- Enhanced ARM64 static library rule to extract and bundle ARM64 secp256k1 objects (just like x64)
|
||||
- Added ARM64 secp256k1 cross-compilation build rule with proper configure options
|
||||
- Updated clean targets to handle ARM64 build artifacts
|
||||
- Modified default targets to build both architectures
|
||||
- Enhanced help documentation
|
||||
|
||||
### 2. Build Script Updates
|
||||
- Updated `build.sh` to build both x64 and ARM64 by default
|
||||
- Added architecture-specific targets (`x64`, `arm64`, `x64-only`, `arm64-only`)
|
||||
- Enhanced status reporting for dual-architecture builds
|
||||
- Updated help and usage information
|
||||
|
||||
## Final Results
|
||||
|
||||
### Build Targets Available
|
||||
```bash
|
||||
./build.sh # Builds both x64 and ARM64 (default)
|
||||
./build.sh x64 # Builds x64 only
|
||||
./build.sh arm64 # Builds ARM64 only
|
||||
./build.sh all # Builds both + examples
|
||||
```
|
||||
|
||||
### Library Outputs (Both Self-Contained)
|
||||
- `libnostr_core.a` (2,431,120 bytes) - x86_64 with bundled secp256k1
|
||||
- `libnostr_core_arm64.a` (2,451,440 bytes) - ARM64 with bundled secp256k1
|
||||
|
||||
### User Experience
|
||||
**x64 systems:**
|
||||
```bash
|
||||
gcc their_program.c -L. -lnostr_core -lm
|
||||
```
|
||||
|
||||
**ARM64 systems:**
|
||||
```bash
|
||||
gcc their_program.c -L. -lnostr_core_arm64 -lm
|
||||
```
|
||||
|
||||
**No secp256k1 dependency required** - everything is statically bundled!
|
||||
|
||||
## Technical Implementation Details
|
||||
|
||||
### Cross-Compilation Process
|
||||
1. **Clean secp256k1 source** - Runs `make distclean` to clear previous builds
|
||||
2. **ARM64 configure** - Cross-compiles secp256k1 with ARM64 toolchain
|
||||
3. **Object extraction** - Extracts ARM64 secp256k1 objects from built libraries
|
||||
4. **Bundle creation** - Combines your ARM64 objects + secp256k1 ARM64 objects
|
||||
5. **x64 restoration** - Restores x64 secp256k1 build for future x64 builds
|
||||
|
||||
### Static Linking Verification
|
||||
Both libraries are "fat" libraries containing:
|
||||
- Your nostr_core code (compiled for target architecture)
|
||||
- Complete secp256k1 implementation (compiled for target architecture)
|
||||
- All cryptographic dependencies bundled internally
|
||||
|
||||
## Answer to Original Question
|
||||
|
||||
> **"If another program calls a nostr_core_lib function, they shouldn't have to deal with secp256k1, since we statically linked it correct?"**
|
||||
|
||||
**YES! Absolutely correct.**
|
||||
|
||||
Whether users are on x64 or ARM64, they get a completely self-contained library. They only need:
|
||||
- Your library file (`libnostr_core.a` or `libnostr_core_arm64.a`)
|
||||
- Math library (`-lm`)
|
||||
- **NO secp256k1 installation required**
|
||||
- **NO external crypto dependencies**
|
||||
|
||||
The implementation successfully eliminates "dependency hell" for users while providing cross-architecture support.
|
||||
|
||||
## Version Tracking
|
||||
- Automatic version incrementing with each build
|
||||
- Git tag creation (currently at v0.1.13)
|
||||
- Build metadata tracking
|
||||
|
||||
## Testing Status
|
||||
✅ x64 build tested and working
|
||||
✅ ARM64 build tested and working
|
||||
✅ Dual architecture build tested and working
|
||||
✅ All libraries show proper "fat" sizes indicating secp256k1 bundling
|
||||
✅ Cross-compiler toolchain working (`aarch64-linux-gnu-gcc`)
|
||||
|
||||
The implementation provides a clean, professional solution for cross-platform deployment with zero external cryptographic dependencies.
|
||||
|
|
@ -0,0 +1,361 @@
|
|||
# Generic Automatic Version Increment System for Any Repository
|
||||
|
||||
Here's a generalized implementation guide for adding automatic versioning to any project:
|
||||
|
||||
## Core Concept
|
||||
**Automatic patch version increment with each build** - Every build automatically increments the patch version: v0.1.0 → v0.1.1 → v0.1.2, etc.
|
||||
|
||||
## Implementation Steps
|
||||
|
||||
### 1. Add Version Increment Function to Build Script
|
||||
Add this function to your build script (bash example):
|
||||
|
||||
```bash
|
||||
# Function to automatically increment version
|
||||
increment_version() {
|
||||
echo "[INFO] Incrementing version..."
|
||||
|
||||
# Check if we're in a git repository
|
||||
if ! git rev-parse --git-dir > /dev/null 2>&1; then
|
||||
echo "[WARNING] Not in a git repository - skipping version increment"
|
||||
return 0
|
||||
fi
|
||||
|
||||
# Get the highest version tag (not chronologically latest)
|
||||
LATEST_TAG=$(git tag -l 'v*.*.*' | sort -V | tail -n 1 || echo "v0.1.0")
|
||||
if [[ -z "$LATEST_TAG" ]]; then
|
||||
LATEST_TAG="v0.1.0"
|
||||
fi
|
||||
|
||||
# Extract version components (remove 'v' prefix)
|
||||
VERSION=${LATEST_TAG#v}
|
||||
|
||||
# Parse major.minor.patch using regex
|
||||
if [[ $VERSION =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
|
||||
MAJOR=${BASH_REMATCH[1]}
|
||||
MINOR=${BASH_REMATCH[2]}
|
||||
PATCH=${BASH_REMATCH[3]}
|
||||
else
|
||||
echo "[ERROR] Invalid version format in tag: $LATEST_TAG"
|
||||
echo "[ERROR] Expected format: v0.1.0"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Increment patch version
|
||||
NEW_PATCH=$((PATCH + 1))
|
||||
NEW_VERSION="v${MAJOR}.${MINOR}.${NEW_PATCH}"
|
||||
|
||||
echo "[INFO] Current version: $LATEST_TAG"
|
||||
echo "[INFO] New version: $NEW_VERSION"
|
||||
|
||||
# Create new git tag
|
||||
if git tag "$NEW_VERSION" 2>/dev/null; then
|
||||
echo "[SUCCESS] Created new version tag: $NEW_VERSION"
|
||||
else
|
||||
echo "[WARNING] Tag $NEW_VERSION already exists - using existing version"
|
||||
NEW_VERSION=$LATEST_TAG
|
||||
fi
|
||||
|
||||
# Update VERSION file for compatibility
|
||||
echo "${NEW_VERSION#v}" > VERSION
|
||||
echo "[SUCCESS] Updated VERSION file to ${NEW_VERSION#v}"
|
||||
}
|
||||
```
|
||||
|
||||
### 2. Generate Version Header Files (For C/C++ Projects)
|
||||
Add this to the increment_version function:
|
||||
|
||||
```bash
|
||||
# Generate version.h header file (adjust path as needed)
|
||||
cat > src/version.h << EOF
|
||||
/*
|
||||
* Auto-Generated Version Header
|
||||
* DO NOT EDIT THIS FILE MANUALLY - Generated by build script
|
||||
*/
|
||||
|
||||
#ifndef VERSION_H
|
||||
#define VERSION_H
|
||||
|
||||
#define VERSION_MAJOR ${MAJOR}
|
||||
#define VERSION_MINOR ${MINOR}
|
||||
#define VERSION_PATCH ${NEW_PATCH}
|
||||
#define VERSION_STRING "${MAJOR}.${MINOR}.${NEW_PATCH}"
|
||||
#define VERSION_TAG "${NEW_VERSION}"
|
||||
|
||||
/* Build information */
|
||||
#define BUILD_DATE "$(date +%Y-%m-%d)"
|
||||
#define BUILD_TIME "$(date +%H:%M:%S)"
|
||||
#define BUILD_TIMESTAMP "$(date '+%Y-%m-%d %H:%M:%S')"
|
||||
|
||||
/* Git information */
|
||||
#define GIT_HASH "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
|
||||
#define GIT_BRANCH "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
|
||||
|
||||
/* Display versions */
|
||||
#define VERSION_DISPLAY "${NEW_VERSION}"
|
||||
#define VERSION_FULL_DISPLAY "${NEW_VERSION} ($(date '+%Y-%m-%d %H:%M:%S'), $(git rev-parse --short HEAD 2>/dev/null || echo 'unknown'))"
|
||||
|
||||
/* Version API functions */
|
||||
const char* get_version(void);
|
||||
const char* get_version_full(void);
|
||||
const char* get_build_info(void);
|
||||
|
||||
#endif /* VERSION_H */
|
||||
EOF
|
||||
|
||||
# Generate version.c implementation file
|
||||
cat > src/version.c << EOF
|
||||
/*
|
||||
* Auto-Generated Version Implementation
|
||||
* DO NOT EDIT THIS FILE MANUALLY - Generated by build script
|
||||
*/
|
||||
|
||||
#include "version.h"
|
||||
|
||||
const char* get_version(void) {
|
||||
return VERSION_TAG;
|
||||
}
|
||||
|
||||
const char* get_version_full(void) {
|
||||
return VERSION_FULL_DISPLAY;
|
||||
}
|
||||
|
||||
const char* get_build_info(void) {
|
||||
return "Built on " BUILD_DATE " at " BUILD_TIME " from commit " GIT_HASH " on branch " GIT_BRANCH;
|
||||
}
|
||||
EOF
|
||||
```
|
||||
|
||||
### 3. Generate Version File for Other Languages
|
||||
|
||||
**Python (`src/__version__.py`):**
|
||||
```bash
|
||||
cat > src/__version__.py << EOF
|
||||
"""Auto-generated version file"""
|
||||
__version__ = "${MAJOR}.${MINOR}.${NEW_PATCH}"
|
||||
__version_tag__ = "${NEW_VERSION}"
|
||||
__build_date__ = "$(date +%Y-%m-%d)"
|
||||
__build_time__ = "$(date +%H:%M:%S)"
|
||||
__git_hash__ = "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
|
||||
__git_branch__ = "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
|
||||
EOF
|
||||
```
|
||||
|
||||
**JavaScript/Node.js (update `package.json`):**
|
||||
```bash
|
||||
# Update package.json version field
|
||||
if [ -f package.json ]; then
|
||||
sed -i "s/\"version\": \".*\"/\"version\": \"${MAJOR}.${MINOR}.${NEW_PATCH}\"/" package.json
|
||||
fi
|
||||
```
|
||||
|
||||
**Rust (update `Cargo.toml`):**
|
||||
```bash
|
||||
if [ -f Cargo.toml ]; then
|
||||
sed -i "s/^version = \".*\"/version = \"${MAJOR}.${MINOR}.${NEW_PATCH}\"/" Cargo.toml
|
||||
fi
|
||||
```
|
||||
|
||||
**Go (generate `version.go`):**
|
||||
```bash
|
||||
cat > version.go << EOF
|
||||
// Auto-generated version file
|
||||
package main
|
||||
|
||||
const (
|
||||
VersionMajor = ${MAJOR}
|
||||
VersionMinor = ${MINOR}
|
||||
VersionPatch = ${NEW_PATCH}
|
||||
VersionString = "${MAJOR}.${MINOR}.${NEW_PATCH}"
|
||||
VersionTag = "${NEW_VERSION}"
|
||||
BuildDate = "$(date +%Y-%m-%d)"
|
||||
BuildTime = "$(date +%H:%M:%S)"
|
||||
GitHash = "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
|
||||
GitBranch = "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
|
||||
)
|
||||
EOF
|
||||
```
|
||||
|
||||
**Java (generate `Version.java`):**
|
||||
```bash
|
||||
cat > src/main/java/Version.java << EOF
|
||||
// Auto-generated version class
|
||||
public class Version {
|
||||
public static final int VERSION_MAJOR = ${MAJOR};
|
||||
public static final int VERSION_MINOR = ${MINOR};
|
||||
public static final int VERSION_PATCH = ${NEW_PATCH};
|
||||
public static final String VERSION_STRING = "${MAJOR}.${MINOR}.${NEW_PATCH}";
|
||||
public static final String VERSION_TAG = "${NEW_VERSION}";
|
||||
public static final String BUILD_DATE = "$(date +%Y-%m-%d)";
|
||||
public static final String BUILD_TIME = "$(date +%H:%M:%S)";
|
||||
public static final String GIT_HASH = "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')";
|
||||
public static final String GIT_BRANCH = "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')";
|
||||
}
|
||||
EOF
|
||||
```
|
||||
|
||||
### 4. Integrate into Build Targets
|
||||
Call `increment_version` before your main build commands:
|
||||
|
||||
```bash
|
||||
build_library() {
|
||||
increment_version
|
||||
echo "[INFO] Building library..."
|
||||
# Your actual build commands here
|
||||
make clean && make
|
||||
}
|
||||
|
||||
build_release() {
|
||||
increment_version
|
||||
echo "[INFO] Building release..."
|
||||
# Your release build commands
|
||||
}
|
||||
|
||||
build_package() {
|
||||
increment_version
|
||||
echo "[INFO] Building package..."
|
||||
# Your packaging commands
|
||||
}
|
||||
```
|
||||
|
||||
### 5. Update .gitignore
|
||||
Add generated version files to `.gitignore`:
|
||||
|
||||
```gitignore
|
||||
# Auto-generated version files
|
||||
src/version.h
|
||||
src/version.c
|
||||
src/__version__.py
|
||||
version.go
|
||||
src/main/java/Version.java
|
||||
VERSION
|
||||
```
|
||||
|
||||
### 6. Update Build System Files
|
||||
|
||||
**For Makefile projects:**
|
||||
```makefile
|
||||
# Add version.c to your source files
|
||||
SOURCES = main.c utils.c version.c
|
||||
```
|
||||
|
||||
**For CMake projects:**
|
||||
```cmake
|
||||
# Add version files to your target
|
||||
target_sources(your_target PRIVATE src/version.c)
|
||||
```
|
||||
|
||||
**For Node.js projects:**
|
||||
```json
|
||||
{
|
||||
"scripts": {
|
||||
"build": "node build.js && increment_version",
|
||||
"version": "node -e \"console.log(require('./package.json').version)\""
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 7. Create Initial Version Tag
|
||||
```bash
|
||||
# Start with initial version
|
||||
git tag v0.1.0
|
||||
```
|
||||
|
||||
## Usage Pattern
|
||||
```bash
|
||||
./build.sh # v0.1.0 → v0.1.1
|
||||
./build.sh release # v0.1.1 → v0.1.2
|
||||
./build.sh package # v0.1.2 → v0.1.3
|
||||
```
|
||||
|
||||
## Manual Version Control
|
||||
|
||||
### Major/Minor Version Bumps
|
||||
```bash
|
||||
# For feature releases (minor bump)
|
||||
git tag v0.2.0 # Next build: v0.2.1
|
||||
|
||||
# For breaking changes (major bump)
|
||||
git tag v1.0.0 # Next build: v1.0.1
|
||||
```
|
||||
|
||||
### Version Reset
|
||||
```bash
|
||||
# Delete incorrect tags (if needed)
|
||||
git tag -d v0.2.1
|
||||
git push origin --delete v0.2.1 # If pushed to remote
|
||||
|
||||
# Create correct base version
|
||||
git tag v0.2.0
|
||||
|
||||
# Next build will create v0.2.1
|
||||
```
|
||||
|
||||
## Example Build Script Template
|
||||
```bash
|
||||
#!/bin/bash
|
||||
set -e
|
||||
|
||||
# Colors for output
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
BLUE='\033[0;34m'
|
||||
NC='\033[0m'
|
||||
|
||||
print_status() { echo -e "${BLUE}[INFO]${NC} $1"; }
|
||||
print_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
|
||||
print_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
|
||||
print_error() { echo -e "${RED}[ERROR]${NC} $1"; }
|
||||
|
||||
# Insert increment_version function here
|
||||
|
||||
case "${1:-build}" in
|
||||
build)
|
||||
increment_version
|
||||
print_status "Building project..."
|
||||
# Your build commands
|
||||
;;
|
||||
clean)
|
||||
print_status "Cleaning build artifacts..."
|
||||
# Your clean commands
|
||||
;;
|
||||
test)
|
||||
print_status "Running tests..."
|
||||
# Your test commands (no version increment)
|
||||
;;
|
||||
release)
|
||||
increment_version
|
||||
print_status "Building release..."
|
||||
# Your release commands
|
||||
;;
|
||||
*)
|
||||
echo "Usage: $0 {build|clean|test|release}"
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
```
|
||||
|
||||
## Benefits
|
||||
1. **Zero maintenance** - No manual version editing
|
||||
2. **Build traceability** - Every build has unique version + metadata
|
||||
3. **Git integration** - Automatic version tags
|
||||
4. **Language agnostic** - Adapt generation for any language
|
||||
5. **CI/CD friendly** - Works in automated environments
|
||||
6. **Rollback friendly** - Easy to revert to previous versions
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Version Not Incrementing
|
||||
- Ensure you're in a git repository
|
||||
- Check that git tags exist: `git tag --list`
|
||||
- Verify tag format matches `v*.*.*` pattern
|
||||
|
||||
### Tag Already Exists
|
||||
If a tag already exists, the build continues with existing version:
|
||||
```
|
||||
[WARNING] Tag v0.2.1 already exists - using existing version
|
||||
```
|
||||
|
||||
### Missing Git Information
|
||||
If git is unavailable, version files show "unknown" for git hash and branch.
|
||||
109
Makefile
109
Makefile
|
|
@ -17,10 +17,18 @@ endif
|
|||
INCLUDES = -I. -Inostr_core -Icjson -Isecp256k1/include -Inostr_websocket -Imbedtls/include -Imbedtls/tf-psa-crypto/include -Imbedtls/tf-psa-crypto/drivers/builtin/include
|
||||
|
||||
# Library source files
|
||||
LIB_SOURCES = nostr_core/core.c nostr_core/core_relays.c nostr_core/nostr_crypto.c nostr_core/nostr_secp256k1.c nostr_core/nostr_aes.c nostr_core/nostr_chacha20.c nostr_websocket/nostr_websocket_mbedtls.c cjson/cJSON.c
|
||||
LIB_SOURCES = nostr_core/core.c nostr_core/core_relays.c nostr_core/nostr_crypto.c nostr_core/nostr_secp256k1.c nostr_core/nostr_aes.c nostr_core/nostr_chacha20.c nostr_core/version.c nostr_websocket/nostr_websocket_mbedtls.c cjson/cJSON.c
|
||||
LIB_OBJECTS = $(LIB_SOURCES:.c=.o)
|
||||
ARM64_LIB_OBJECTS = $(LIB_SOURCES:.c=.arm64.o)
|
||||
|
||||
# secp256k1 library paths
|
||||
SECP256K1_LIB = ./secp256k1/.libs/libsecp256k1.a
|
||||
SECP256K1_PRECOMPUTED_LIB = ./secp256k1/.libs/libsecp256k1_precomputed.a
|
||||
|
||||
# ARM64 secp256k1 library paths
|
||||
SECP256K1_ARM64_LIB = ./secp256k1/.libs/libsecp256k1_arm64.a
|
||||
SECP256K1_ARM64_PRECOMPUTED_LIB = ./secp256k1/.libs/libsecp256k1_precomputed_arm64.a
|
||||
|
||||
# Library outputs (static only)
|
||||
STATIC_LIB = libnostr_core.a
|
||||
ARM64_STATIC_LIB = libnostr_core_arm64.a
|
||||
|
|
@ -29,27 +37,72 @@ ARM64_STATIC_LIB = libnostr_core_arm64.a
|
|||
EXAMPLE_SOURCES = $(wildcard examples/*.c)
|
||||
EXAMPLE_TARGETS = $(EXAMPLE_SOURCES:.c=)
|
||||
|
||||
# Default target - build static library
|
||||
default: $(STATIC_LIB)
|
||||
# Default target - build both x64 and ARM64 static libraries
|
||||
default: $(STATIC_LIB) $(ARM64_STATIC_LIB)
|
||||
|
||||
# Build all targets (static only)
|
||||
all: $(STATIC_LIB) examples
|
||||
all: $(STATIC_LIB) $(ARM64_STATIC_LIB) examples
|
||||
|
||||
# Static library
|
||||
$(STATIC_LIB): $(LIB_OBJECTS)
|
||||
@echo "Creating static library: $@"
|
||||
$(AR) rcs $@ $^
|
||||
# Static library - includes secp256k1 objects for self-contained library
|
||||
$(STATIC_LIB): $(LIB_OBJECTS) $(SECP256K1_LIB)
|
||||
@echo "Creating self-contained static library: $@"
|
||||
@echo "Extracting secp256k1 objects..."
|
||||
@mkdir -p .tmp_secp256k1
|
||||
@cd .tmp_secp256k1 && $(AR) x ../$(SECP256K1_LIB)
|
||||
@if [ -f $(SECP256K1_PRECOMPUTED_LIB) ]; then \
|
||||
echo "Extracting secp256k1_precomputed objects..."; \
|
||||
cd .tmp_secp256k1 && $(AR) x ../$(SECP256K1_PRECOMPUTED_LIB); \
|
||||
fi
|
||||
@echo "Combining all objects into $@..."
|
||||
$(AR) rcs $@ $(LIB_OBJECTS) .tmp_secp256k1/*.o
|
||||
@rm -rf .tmp_secp256k1
|
||||
@echo "Self-contained static library created: $@"
|
||||
|
||||
# ARM64 cross-compilation settings
|
||||
ARM64_CC = aarch64-linux-gnu-gcc
|
||||
ARM64_AR = aarch64-linux-gnu-ar
|
||||
ARM64_INCLUDES = -I. -Inostr_core -Icjson
|
||||
ARM64_INCLUDES = -I. -Inostr_core -Icjson -Isecp256k1/include -Inostr_websocket -Imbedtls/include -Imbedtls/tf-psa-crypto/include -Imbedtls/tf-psa-crypto/drivers/builtin/include
|
||||
|
||||
# ARM64 static library
|
||||
$(ARM64_STATIC_LIB): $(ARM64_LIB_OBJECTS)
|
||||
@echo "Creating ARM64 static library: $@"
|
||||
$(ARM64_AR) rcs $@ $^
|
||||
# ARM64 static library - includes secp256k1 objects for self-contained library
|
||||
$(ARM64_STATIC_LIB): $(ARM64_LIB_OBJECTS) $(SECP256K1_ARM64_LIB)
|
||||
@echo "Creating self-contained ARM64 static library: $@"
|
||||
@echo "Extracting ARM64 secp256k1 objects..."
|
||||
@mkdir -p .tmp_secp256k1_arm64
|
||||
@cd .tmp_secp256k1_arm64 && $(ARM64_AR) x ../$(SECP256K1_ARM64_LIB)
|
||||
@if [ -f $(SECP256K1_ARM64_PRECOMPUTED_LIB) ]; then \
|
||||
echo "Extracting ARM64 secp256k1_precomputed objects..."; \
|
||||
cd .tmp_secp256k1_arm64 && $(ARM64_AR) x ../$(SECP256K1_ARM64_PRECOMPUTED_LIB); \
|
||||
fi
|
||||
@echo "Combining all ARM64 objects into $@..."
|
||||
$(ARM64_AR) rcs $@ $(ARM64_LIB_OBJECTS) .tmp_secp256k1_arm64/*.o
|
||||
@rm -rf .tmp_secp256k1_arm64
|
||||
@echo "Self-contained ARM64 static library created: $@"
|
||||
|
||||
# Build secp256k1 for ARM64
|
||||
$(SECP256K1_ARM64_LIB): secp256k1/configure
|
||||
@echo "Building secp256k1 for ARM64..."
|
||||
@echo "Cleaning secp256k1 source directory first..."
|
||||
@cd secp256k1 && make distclean 2>/dev/null || true
|
||||
@mkdir -p secp256k1/build_arm64
|
||||
@cd secp256k1/build_arm64 && \
|
||||
CC=$(ARM64_CC) AR=$(ARM64_AR) \
|
||||
../configure --host=aarch64-linux-gnu \
|
||||
--enable-module-schnorrsig \
|
||||
--enable-module-ecdh \
|
||||
--enable-experimental \
|
||||
--disable-shared \
|
||||
--enable-static \
|
||||
--with-pic \
|
||||
--prefix=$(PWD)/secp256k1/install_arm64 && \
|
||||
make -j$(shell nproc 2>/dev/null || echo 4)
|
||||
@mkdir -p secp256k1/.libs
|
||||
@cp secp256k1/build_arm64/.libs/libsecp256k1.a $(SECP256K1_ARM64_LIB)
|
||||
@if [ -f secp256k1/build_arm64/.libs/libsecp256k1_precomputed.a ]; then \
|
||||
cp secp256k1/build_arm64/.libs/libsecp256k1_precomputed.a $(SECP256K1_ARM64_PRECOMPUTED_LIB); \
|
||||
fi
|
||||
@echo "ARM64 secp256k1 libraries built successfully"
|
||||
@echo "Restoring x64 secp256k1 build..."
|
||||
@cd secp256k1 && ./configure --enable-module-schnorrsig --enable-module-ecdh --enable-experimental --disable-shared --enable-static --with-pic >/dev/null 2>&1 && make -j$(shell nproc 2>/dev/null || echo 4) >/dev/null 2>&1 || true
|
||||
|
||||
# Object files (x86_64)
|
||||
%.o: %.c
|
||||
|
|
@ -66,11 +119,16 @@ examples: $(EXAMPLE_TARGETS)
|
|||
|
||||
examples/%: examples/%.c $(STATIC_LIB)
|
||||
@echo "Building example: $@"
|
||||
$(CC) $(STATIC_CFLAGS) $(LOGGING_FLAGS) $(INCLUDES) $< -o $@ ./libnostr_core.a ./secp256k1/.libs/libsecp256k1.a -lm
|
||||
$(CC) $(STATIC_CFLAGS) $(LOGGING_FLAGS) $(INCLUDES) $< -o $@ ./libnostr_core.a -lm
|
||||
|
||||
# Architecture-specific targets
|
||||
x64: $(STATIC_LIB)
|
||||
x64-only: $(STATIC_LIB)
|
||||
|
||||
# ARM64 targets
|
||||
arm64: $(ARM64_STATIC_LIB)
|
||||
arm64-all: $(ARM64_STATIC_LIB)
|
||||
arm64-only: $(ARM64_STATIC_LIB)
|
||||
|
||||
# Debug build
|
||||
debug: CFLAGS = $(DEBUG_CFLAGS)
|
||||
|
|
@ -105,7 +163,10 @@ clean:
|
|||
@echo "Cleaning build artifacts..."
|
||||
rm -f $(LIB_OBJECTS) $(ARM64_LIB_OBJECTS)
|
||||
rm -f $(STATIC_LIB) $(ARM64_STATIC_LIB)
|
||||
rm -f $(SECP256K1_ARM64_LIB) $(SECP256K1_ARM64_PRECOMPUTED_LIB)
|
||||
rm -f $(EXAMPLE_TARGETS)
|
||||
rm -rf .tmp_secp256k1 .tmp_secp256k1_arm64
|
||||
rm -rf secp256k1/build_arm64 secp256k1/install_arm64
|
||||
|
||||
# Create distribution package
|
||||
dist: clean
|
||||
|
|
@ -121,11 +182,14 @@ help:
|
|||
@echo "==============================="
|
||||
@echo ""
|
||||
@echo "Available targets:"
|
||||
@echo " default - Build static library (recommended)"
|
||||
@echo " all - Build static library and examples"
|
||||
@echo " arm64 - Build ARM64 static library"
|
||||
@echo " arm64-all - Build ARM64 static library"
|
||||
@echo " debug - Build with debug symbols"
|
||||
@echo " default - Build both x64 and ARM64 static libraries (recommended)"
|
||||
@echo " all - Build both architectures and examples"
|
||||
@echo " x64 - Build x64 static library only"
|
||||
@echo " x64-only - Build x64 static library only"
|
||||
@echo " arm64 - Build ARM64 static library only"
|
||||
@echo " arm64-only - Build ARM64 static library only"
|
||||
@echo " arm64-all - Build ARM64 static library only"
|
||||
@echo " debug - Build with debug symbols (both architectures)"
|
||||
@echo " examples - Build example programs"
|
||||
@echo " test - Run simple test"
|
||||
@echo " test-crypto - Run comprehensive crypto test suite"
|
||||
|
|
@ -135,8 +199,11 @@ help:
|
|||
@echo " dist - Create distribution package"
|
||||
@echo " help - Show this help"
|
||||
@echo ""
|
||||
@echo "Library outputs (static only):"
|
||||
@echo "Library outputs (static only, self-contained with secp256k1):"
|
||||
@echo " $(STATIC_LIB) - x86_64 static library"
|
||||
@echo " $(ARM64_STATIC_LIB) - ARM64 static library"
|
||||
@echo ""
|
||||
@echo "Both libraries are self-contained and include secp256k1 objects."
|
||||
@echo "Users only need to link with the library + -lm (no secp256k1 dependency)."
|
||||
|
||||
.PHONY: default all arm64 arm64-all debug examples test test-crypto install uninstall clean dist help
|
||||
.PHONY: default all x64 x64-only arm64 arm64-all arm64-only debug examples test test-crypto install uninstall clean dist help
|
||||
|
|
|
|||
|
|
@ -0,0 +1,433 @@
|
|||
# NOSTR Core Library
|
||||
|
||||
A comprehensive, self-contained C library for NOSTR protocol implementation with no external cryptographic dependencies.
|
||||
|
||||
[](VERSION)
|
||||
[](#license)
|
||||
[](#building)
|
||||
|
||||
## 🚀 Features
|
||||
|
||||
### Core Protocol Support
|
||||
- **NIP-01**: Basic protocol flow - event creation, signing, and validation
|
||||
- **NIP-04**: Encrypted direct messages (ECDH + AES-CBC + Base64)
|
||||
- **NIP-06**: Key derivation from mnemonic (BIP39/BIP32 compliant)
|
||||
- **NIP-13**: Proof of Work for events
|
||||
- **NIP-44**: Versioned encrypted direct messages (ECDH + ChaCha20 + HMAC)
|
||||
|
||||
### Cryptographic Features
|
||||
- **Self-Contained**: No external crypto dependencies (OpenSSL, libwally, etc.)
|
||||
- **Secp256k1**: Complete elliptic curve implementation bundled
|
||||
- **BIP39**: Mnemonic phrase generation and validation
|
||||
- **BIP32**: Hierarchical deterministic key derivation
|
||||
- **ChaCha20**: Stream cipher for NIP-44 encryption
|
||||
- **AES-CBC**: Block cipher for NIP-04 encryption
|
||||
- **Schnorr Signatures**: BIP-340 compliant signing and verification
|
||||
|
||||
### Networking & Relay Support
|
||||
- **Multi-Relay Queries**: Synchronous querying with progress callbacks
|
||||
- **Relay Pools**: Asynchronous connection management with statistics
|
||||
- **WebSocket Communication**: Full relay protocol support
|
||||
- **Event Deduplication**: Automatic handling of duplicate events across relays
|
||||
- **Connection Management**: Automatic reconnection and error handling
|
||||
|
||||
### Developer Experience
|
||||
- **Zero Dependencies**: Only requires standard C library and math library (`-lm`)
|
||||
- **Thread-Safe**: Core cryptographic functions are stateless
|
||||
- **Cross-Platform**: Builds on Linux, macOS, Windows
|
||||
- **Comprehensive Examples**: Ready-to-run demonstration programs
|
||||
- **Automatic Versioning**: Git-tag based version management
|
||||
|
||||
## 📦 Quick Start
|
||||
|
||||
### Installation
|
||||
|
||||
1. **Clone the repository:**
|
||||
```bash
|
||||
git clone https://github.com/yourusername/nostr_core_lib.git
|
||||
cd nostr_core_lib
|
||||
```
|
||||
|
||||
2. **Build the library:**
|
||||
```bash
|
||||
./build.sh lib
|
||||
```
|
||||
|
||||
3. **Run examples:**
|
||||
```bash
|
||||
./build.sh examples
|
||||
./examples/simple_keygen
|
||||
```
|
||||
|
||||
### Usage Example
|
||||
|
||||
```c
|
||||
#include "nostr_core/nostr_core.h"
|
||||
#include <stdio.h>
|
||||
|
||||
int main() {
|
||||
// Initialize library
|
||||
if (nostr_init() != NOSTR_SUCCESS) {
|
||||
fprintf(stderr, "Failed to initialize NOSTR library\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Generate keypair
|
||||
unsigned char private_key[32], public_key[32];
|
||||
nostr_generate_keypair(private_key, public_key);
|
||||
|
||||
// Convert to bech32 format
|
||||
char nsec[100], npub[100];
|
||||
nostr_key_to_bech32(private_key, "nsec", nsec);
|
||||
nostr_key_to_bech32(public_key, "npub", npub);
|
||||
|
||||
printf("Private key: %s\n", nsec);
|
||||
printf("Public key: %s\n", npub);
|
||||
|
||||
// Create and sign event
|
||||
cJSON* event = nostr_create_and_sign_event(1, "Hello NOSTR!", NULL, private_key, 0);
|
||||
if (event) {
|
||||
char* json = cJSON_Print(event);
|
||||
printf("Event: %s\n", json);
|
||||
free(json);
|
||||
cJSON_Delete(event);
|
||||
}
|
||||
|
||||
nostr_cleanup();
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
**Compile and run:**
|
||||
```bash
|
||||
gcc example.c -o example ./libnostr_core.a -lm
|
||||
./example
|
||||
```
|
||||
|
||||
## 🏗️ Building
|
||||
|
||||
### Build Targets
|
||||
|
||||
```bash
|
||||
./build.sh lib # Build static library (default)
|
||||
./build.sh examples # Build examples
|
||||
./build.sh test # Run test suite
|
||||
./build.sh clean # Clean build artifacts
|
||||
./build.sh install # Install to system
|
||||
```
|
||||
|
||||
### Manual Building
|
||||
|
||||
```bash
|
||||
# Build static library
|
||||
make
|
||||
|
||||
# Build examples
|
||||
make examples
|
||||
|
||||
# Run tests
|
||||
make test-crypto
|
||||
|
||||
# Clean
|
||||
make clean
|
||||
```
|
||||
|
||||
### Dependencies
|
||||
|
||||
**Required:**
|
||||
- GCC or compatible C compiler
|
||||
- Standard C library
|
||||
- Math library (`-lm`)
|
||||
|
||||
**Included:**
|
||||
- cJSON (JSON parsing)
|
||||
- secp256k1 (elliptic curve cryptography)
|
||||
- mbedTLS components (selected crypto functions)
|
||||
|
||||
## 📚 API Documentation
|
||||
|
||||
### Initialization
|
||||
```c
|
||||
int nostr_init(void); // Initialize library (call first)
|
||||
void nostr_cleanup(void); // Cleanup resources (call last)
|
||||
const char* nostr_strerror(int error); // Get error message
|
||||
```
|
||||
|
||||
### Key Management
|
||||
```c
|
||||
// Generate random keypair
|
||||
int nostr_generate_keypair(unsigned char* private_key, unsigned char* public_key);
|
||||
|
||||
// Generate from mnemonic
|
||||
int nostr_generate_mnemonic_and_keys(char* mnemonic, size_t mnemonic_size,
|
||||
int account, unsigned char* private_key,
|
||||
unsigned char* public_key);
|
||||
|
||||
// Derive from existing mnemonic
|
||||
int nostr_derive_keys_from_mnemonic(const char* mnemonic, int account,
|
||||
unsigned char* private_key, unsigned char* public_key);
|
||||
|
||||
// Format conversion
|
||||
int nostr_key_to_bech32(const unsigned char* key, const char* hrp, char* output);
|
||||
nostr_input_type_t nostr_detect_input_type(const char* input);
|
||||
```
|
||||
|
||||
### Event Creation
|
||||
```c
|
||||
// Create and sign event
|
||||
cJSON* nostr_create_and_sign_event(int kind, const char* content, cJSON* tags,
|
||||
const unsigned char* private_key, time_t timestamp);
|
||||
|
||||
// Add proof of work
|
||||
int nostr_add_proof_of_work(cJSON* event, const unsigned char* private_key,
|
||||
int target_difficulty, void (*progress_callback)(...), void* user_data);
|
||||
```
|
||||
|
||||
### Encryption (NIP-04 & NIP-44)
|
||||
```c
|
||||
// NIP-04 (AES-CBC)
|
||||
int nostr_nip04_encrypt(const unsigned char* sender_private_key,
|
||||
const unsigned char* recipient_public_key,
|
||||
const char* plaintext, char* output, size_t output_size);
|
||||
|
||||
int nostr_nip04_decrypt(const unsigned char* recipient_private_key,
|
||||
const unsigned char* sender_public_key,
|
||||
const char* encrypted_data, char* output, size_t output_size);
|
||||
|
||||
// NIP-44 (ChaCha20)
|
||||
int nostr_nip44_encrypt(const unsigned char* sender_private_key,
|
||||
const unsigned char* recipient_public_key,
|
||||
const char* plaintext, char* output, size_t output_size);
|
||||
|
||||
int nostr_nip44_decrypt(const unsigned char* recipient_private_key,
|
||||
const unsigned char* sender_public_key,
|
||||
const char* encrypted_data, char* output, size_t output_size);
|
||||
```
|
||||
|
||||
### Relay Communication
|
||||
```c
|
||||
// Simple relay query
|
||||
cJSON* nostr_query_relay_for_event(const char* relay_url, const char* pubkey_hex, int kind);
|
||||
|
||||
// Multi-relay synchronous queries
|
||||
cJSON** synchronous_query_relays_with_progress(const char** relay_urls, int relay_count,
|
||||
cJSON* filter, relay_query_mode_t mode,
|
||||
int* result_count, int relay_timeout_seconds,
|
||||
relay_progress_callback_t callback, void* user_data);
|
||||
|
||||
// Multi-relay publishing
|
||||
publish_result_t* synchronous_publish_event_with_progress(const char** relay_urls, int relay_count,
|
||||
cJSON* event, int* success_count,
|
||||
int relay_timeout_seconds,
|
||||
publish_progress_callback_t callback, void* user_data);
|
||||
```
|
||||
|
||||
### Relay Pools (Asynchronous)
|
||||
```c
|
||||
// Create and manage relay pool
|
||||
nostr_relay_pool_t* nostr_relay_pool_create(void);
|
||||
int nostr_relay_pool_add_relay(nostr_relay_pool_t* pool, const char* relay_url);
|
||||
void nostr_relay_pool_destroy(nostr_relay_pool_t* pool);
|
||||
|
||||
// Subscribe to events
|
||||
nostr_pool_subscription_t* nostr_relay_pool_subscribe(
|
||||
nostr_relay_pool_t* pool, const char** relay_urls, int relay_count, cJSON* filter,
|
||||
void (*on_event)(cJSON* event, const char* relay_url, void* user_data),
|
||||
void (*on_eose)(void* user_data), void* user_data);
|
||||
|
||||
// Run event loop
|
||||
int nostr_relay_pool_run(nostr_relay_pool_t* pool, int timeout_ms);
|
||||
int nostr_relay_pool_poll(nostr_relay_pool_t* pool, int timeout_ms);
|
||||
```
|
||||
|
||||
## 📁 Examples
|
||||
|
||||
The library includes comprehensive examples:
|
||||
|
||||
- **`simple_keygen`** - Basic key generation and formatting
|
||||
- **`keypair_generation`** - Advanced key management
|
||||
- **`mnemonic_generation`** - BIP39 mnemonic handling
|
||||
- **`mnemonic_derivation`** - NIP-06 key derivation
|
||||
- **`utility_functions`** - General utility demonstrations
|
||||
- **`input_detection`** - Input type detection and processing
|
||||
- **`version_test`** - Library version information
|
||||
|
||||
Run all examples:
|
||||
```bash
|
||||
./build.sh examples
|
||||
ls -la examples/
|
||||
```
|
||||
|
||||
## 🧪 Testing
|
||||
|
||||
The library includes extensive tests:
|
||||
|
||||
```bash
|
||||
# Run all tests
|
||||
./build.sh test
|
||||
|
||||
# Individual test categories
|
||||
cd tests && make test
|
||||
```
|
||||
|
||||
**Test Categories:**
|
||||
- **Core Functionality**: `simple_init_test`, `header_test`
|
||||
- **Cryptography**: `chacha20_test`, `nostr_crypto_test`
|
||||
- **NIP-04 Encryption**: `nip04_test`
|
||||
- **NIP-44 Encryption**: `nip44_test`, `nip44_debug_test`
|
||||
- **Key Derivation**: `nostr_test_bip32`
|
||||
- **Relay Communication**: `relay_pool_test`, `sync_test`
|
||||
- **Proof of Work**: `test_pow_loop`
|
||||
|
||||
## 🏗️ Integration
|
||||
|
||||
### Static Library Integration
|
||||
|
||||
1. **Copy required files to your project:**
|
||||
```bash
|
||||
cp libnostr_core.a /path/to/your/project/
|
||||
cp nostr_core/nostr_core.h /path/to/your/project/
|
||||
```
|
||||
|
||||
2. **Link in your project:**
|
||||
```bash
|
||||
gcc your_code.c -L. -lnostr_core -lm -o your_program
|
||||
```
|
||||
|
||||
### Source Integration
|
||||
|
||||
1. **Copy source files:**
|
||||
```bash
|
||||
cp -r nostr_core/ /path/to/your/project/
|
||||
cp -r cjson/ /path/to/your/project/
|
||||
```
|
||||
|
||||
2. **Include in your build:**
|
||||
```bash
|
||||
gcc your_code.c nostr_core/*.c cjson/cJSON.c -lm -o your_program
|
||||
```
|
||||
|
||||
### Self-Contained Library
|
||||
|
||||
The `libnostr_core.a` file is completely self-contained with **no external dependencies**:
|
||||
|
||||
- ✅ **No OpenSSL required**
|
||||
- ✅ **No libwally required**
|
||||
- ✅ **No system secp256k1 required**
|
||||
- ✅ **Only needs math library (`-lm`)**
|
||||
|
||||
```bash
|
||||
# This is all you need:
|
||||
gcc your_app.c ./libnostr_core.a -lm -o your_app
|
||||
```
|
||||
|
||||
## 🔧 Configuration
|
||||
|
||||
### Compile-Time Options
|
||||
|
||||
```c
|
||||
// Enable debug output
|
||||
#define NOSTR_DEBUG_ENABLED
|
||||
|
||||
// Crypto-only build (no networking)
|
||||
#define NOSTR_CRYPTO_ONLY
|
||||
|
||||
// Enable specific NIPs
|
||||
#define NOSTR_NIP04_ENABLED
|
||||
#define NOSTR_NIP44_ENABLED
|
||||
#define NOSTR_NIP13_ENABLED
|
||||
```
|
||||
|
||||
### Build Flags
|
||||
|
||||
```bash
|
||||
# Enable all logging
|
||||
make LOGGING_FLAGS="-DENABLE_FILE_LOGGING -DENABLE_WEBSOCKET_LOGGING -DENABLE_DEBUG_LOGGING"
|
||||
|
||||
# Debug build
|
||||
make debug
|
||||
|
||||
# ARM64 cross-compile
|
||||
make arm64
|
||||
```
|
||||
|
||||
## 🌐 Supported Platforms
|
||||
|
||||
- **Linux** (x86_64, ARM64)
|
||||
- **macOS** (Intel, Apple Silicon)
|
||||
- **Windows** (MinGW, MSYS2)
|
||||
- **Embedded Systems** (resource-constrained environments)
|
||||
|
||||
## 📄 Documentation
|
||||
|
||||
- **[LIBRARY_USAGE.md](LIBRARY_USAGE.md)** - Detailed integration guide
|
||||
- **[EXPORT_GUIDE.md](EXPORT_GUIDE.md)** - Library export instructions
|
||||
- **[AUTOMATIC_VERSIONING.md](AUTOMATIC_VERSIONING.md)** - Version management
|
||||
- **API Reference** - Complete documentation in `nostr_core/nostr_core.h`
|
||||
|
||||
## 🤝 Contributing
|
||||
|
||||
1. Fork the repository
|
||||
2. Create a feature branch: `git checkout -b feature/amazing-feature`
|
||||
3. Make your changes and add tests
|
||||
4. Run the test suite: `./build.sh test`
|
||||
5. Commit your changes: `git commit -m 'Add amazing feature'`
|
||||
6. Push to the branch: `git push origin feature/amazing-feature`
|
||||
7. Open a Pull Request
|
||||
|
||||
## 📈 Version History
|
||||
|
||||
Current version: **0.1.8**
|
||||
|
||||
The library uses automatic semantic versioning based on Git tags. Each build increments the patch version automatically.
|
||||
|
||||
- `v0.1.x` - Initial development releases
|
||||
- Focus on core protocol implementation and self-contained crypto
|
||||
- Full NIP-01, NIP-04, NIP-06, NIP-13, NIP-44 support
|
||||
|
||||
## 🐛 Troubleshooting
|
||||
|
||||
### Common Issues
|
||||
|
||||
**Build fails with secp256k1 errors:**
|
||||
```bash
|
||||
cd secp256k1
|
||||
./autogen.sh
|
||||
./configure --enable-module-schnorrsig --enable-module-ecdh
|
||||
make
|
||||
cd ..
|
||||
./build.sh lib
|
||||
```
|
||||
|
||||
**Library too large:**
|
||||
The library is intentionally large (~2.4MB) because it includes all secp256k1 cryptographic functions for complete self-containment.
|
||||
|
||||
**Linking errors:**
|
||||
Make sure to include the math library:
|
||||
```bash
|
||||
gcc your_code.c ./libnostr_core.a -lm # Note the -lm flag
|
||||
```
|
||||
|
||||
### Getting Help
|
||||
|
||||
- Check the `examples/` directory for working code
|
||||
- Run `./build.sh test` to verify your environment
|
||||
- Review the comprehensive API documentation in `nostr_core/nostr_core.h`
|
||||
|
||||
## 📜 License
|
||||
|
||||
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
|
||||
|
||||
## 🙏 Acknowledgments
|
||||
|
||||
- **NOSTR Protocol** - The decentralized social media protocol
|
||||
- **secp256k1** - Bitcoin's elliptic curve library
|
||||
- **cJSON** - Lightweight JSON parser
|
||||
- **mbedTLS** - Cryptographic building blocks
|
||||
- **NOSTR Community** - For protocol specification and feedback
|
||||
|
||||
---
|
||||
|
||||
**Built with ❤️ for the decentralized web**
|
||||
|
||||
*Self-contained • Zero dependencies • Production ready*
|
||||
117
build.sh
117
build.sh
|
|
@ -146,23 +146,27 @@ show_usage() {
|
|||
echo "NOSTR Core Library Build Script"
|
||||
echo "==============================="
|
||||
echo ""
|
||||
echo "Usage: $0 [target]"
|
||||
echo "Usage: $0 [target] [architecture]"
|
||||
echo ""
|
||||
echo "Available targets:"
|
||||
echo " clean - Clean all build artifacts"
|
||||
echo " lib - Build static library (default)"
|
||||
echo " shared - Build shared library"
|
||||
echo " all - Build both static and shared libraries"
|
||||
echo " lib - Build static libraries for both x64 and ARM64 (default)"
|
||||
echo " x64 - Build x64 static library only"
|
||||
echo " arm64 - Build ARM64 static library only"
|
||||
echo " all - Build both architectures and examples"
|
||||
echo " examples - Build example programs"
|
||||
echo " test - Run tests"
|
||||
echo " install - Install library to system"
|
||||
echo " uninstall - Remove library from system"
|
||||
echo " help - Show this help message"
|
||||
echo ""
|
||||
echo "Library outputs:"
|
||||
echo " libnostr_core.a - Static library"
|
||||
echo " libnostr_core.so - Shared library"
|
||||
echo "Library outputs (both self-contained with secp256k1):"
|
||||
echo " libnostr_core.a - x86_64 static library"
|
||||
echo " libnostr_core_arm64.a - ARM64 static library"
|
||||
echo " examples/* - Example programs"
|
||||
echo ""
|
||||
echo "Both libraries include secp256k1 objects internally."
|
||||
echo "Users only need to link with the library + -lm."
|
||||
}
|
||||
|
||||
# Parse command line arguments
|
||||
|
|
@ -177,15 +181,63 @@ case "$TARGET" in
|
|||
|
||||
lib|library)
|
||||
increment_version
|
||||
print_status "Building static library..."
|
||||
print_status "Building both x64 and ARM64 static libraries..."
|
||||
make clean
|
||||
make
|
||||
|
||||
# Check both libraries were built
|
||||
SUCCESS=0
|
||||
if [ -f "libnostr_core.a" ]; then
|
||||
SIZE_X64=$(stat -c%s "libnostr_core.a")
|
||||
print_success "x64 static library built successfully (${SIZE_X64} bytes)"
|
||||
SUCCESS=$((SUCCESS + 1))
|
||||
else
|
||||
print_error "Failed to build x64 static library"
|
||||
fi
|
||||
|
||||
if [ -f "libnostr_core_arm64.a" ]; then
|
||||
SIZE_ARM64=$(stat -c%s "libnostr_core_arm64.a")
|
||||
print_success "ARM64 static library built successfully (${SIZE_ARM64} bytes)"
|
||||
SUCCESS=$((SUCCESS + 1))
|
||||
else
|
||||
print_error "Failed to build ARM64 static library"
|
||||
fi
|
||||
|
||||
if [ $SUCCESS -eq 2 ]; then
|
||||
print_success "Both architectures built successfully!"
|
||||
ls -la libnostr_core*.a
|
||||
else
|
||||
print_error "Failed to build all libraries"
|
||||
exit 1
|
||||
fi
|
||||
;;
|
||||
|
||||
x64|x64-only)
|
||||
increment_version
|
||||
print_status "Building x64 static library only..."
|
||||
make clean
|
||||
make x64
|
||||
if [ -f "libnostr_core.a" ]; then
|
||||
SIZE=$(stat -c%s "libnostr_core.a")
|
||||
print_success "Static library built successfully (${SIZE} bytes)"
|
||||
print_success "x64 static library built successfully (${SIZE} bytes)"
|
||||
ls -la libnostr_core.a
|
||||
else
|
||||
print_error "Failed to build static library"
|
||||
print_error "Failed to build x64 static library"
|
||||
exit 1
|
||||
fi
|
||||
;;
|
||||
|
||||
arm64|arm64-only)
|
||||
increment_version
|
||||
print_status "Building ARM64 static library only..."
|
||||
make clean
|
||||
make arm64
|
||||
if [ -f "libnostr_core_arm64.a" ]; then
|
||||
SIZE=$(stat -c%s "libnostr_core_arm64.a")
|
||||
print_success "ARM64 static library built successfully (${SIZE} bytes)"
|
||||
ls -la libnostr_core_arm64.a
|
||||
else
|
||||
print_error "Failed to build ARM64 static library"
|
||||
exit 1
|
||||
fi
|
||||
;;
|
||||
|
|
@ -207,21 +259,54 @@ case "$TARGET" in
|
|||
|
||||
all)
|
||||
increment_version
|
||||
print_status "Building all libraries..."
|
||||
print_status "Building all libraries and examples..."
|
||||
make clean
|
||||
make all
|
||||
print_success "All libraries built successfully"
|
||||
ls -la libnostr_core.*
|
||||
|
||||
# Check both libraries and examples were built
|
||||
SUCCESS=0
|
||||
if [ -f "libnostr_core.a" ]; then
|
||||
SIZE_X64=$(stat -c%s "libnostr_core.a")
|
||||
print_success "x64 static library built successfully (${SIZE_X64} bytes)"
|
||||
SUCCESS=$((SUCCESS + 1))
|
||||
else
|
||||
print_error "Failed to build x64 static library"
|
||||
fi
|
||||
|
||||
if [ -f "libnostr_core_arm64.a" ]; then
|
||||
SIZE_ARM64=$(stat -c%s "libnostr_core_arm64.a")
|
||||
print_success "ARM64 static library built successfully (${SIZE_ARM64} bytes)"
|
||||
SUCCESS=$((SUCCESS + 1))
|
||||
else
|
||||
print_error "Failed to build ARM64 static library"
|
||||
fi
|
||||
|
||||
if [ $SUCCESS -eq 2 ]; then
|
||||
print_success "All libraries and examples built successfully!"
|
||||
ls -la libnostr_core*.a
|
||||
ls -la examples/
|
||||
else
|
||||
print_error "Failed to build all components"
|
||||
exit 1
|
||||
fi
|
||||
;;
|
||||
|
||||
examples)
|
||||
increment_version
|
||||
print_status "Building examples..."
|
||||
print_status "Building both libraries and examples..."
|
||||
make clean
|
||||
make
|
||||
make examples
|
||||
print_success "Examples built successfully"
|
||||
ls -la examples/
|
||||
|
||||
# Verify libraries were built
|
||||
if [ -f "libnostr_core.a" ] && [ -f "libnostr_core_arm64.a" ]; then
|
||||
print_success "Both libraries and examples built successfully"
|
||||
ls -la libnostr_core*.a
|
||||
ls -la examples/
|
||||
else
|
||||
print_error "Failed to build libraries for examples"
|
||||
exit 1
|
||||
fi
|
||||
;;
|
||||
|
||||
test)
|
||||
|
|
|
|||
BIN
libnostr_core.a
BIN
libnostr_core.a
Binary file not shown.
Binary file not shown.
|
|
@ -24,10 +24,11 @@
|
|||
// UTILITY FUNCTIONS
|
||||
// =============================================================================
|
||||
|
||||
// Memory clearing utility
|
||||
static void memory_clear(void *p, size_t len) {
|
||||
// Memory clearing utility - accepts const pointers for security clearing
|
||||
static void memory_clear(const void *p, size_t len) {
|
||||
if (p && len) {
|
||||
memset(p, 0, len);
|
||||
// Cast away const for memset - this is safe for security clearing
|
||||
memset((void *)p, 0, len);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ RELAY_POOL_TEST_EXEC = relay_pool_test
|
|||
EVENT_GEN_TEST_EXEC = test_event_generation
|
||||
POW_LOOP_TEST_EXEC = test_pow_loop
|
||||
NIP04_TEST_EXEC = nip04_test
|
||||
STATIC_LINKING_TEST_EXEC = static_linking_only_test
|
||||
ARM64_CRYPTO_TEST_EXEC = nostr_crypto_test_arm64
|
||||
ARM64_CORE_TEST_EXEC = nostr_core_test_arm64
|
||||
ARM64_RELAY_POOL_TEST_EXEC = relay_pool_test_arm64
|
||||
|
|
@ -54,6 +55,11 @@ $(NIP04_TEST_EXEC): nip04_test.c
|
|||
@echo "Building NIP-04 encryption test suite (x86_64)..."
|
||||
$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
|
||||
|
||||
# Build static linking test executable (x86_64)
|
||||
$(STATIC_LINKING_TEST_EXEC): static_linking_only_test.c
|
||||
@echo "Building static linking verification test (x86_64)..."
|
||||
$(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
|
||||
|
||||
# Build simple initialization test executable (x86_64)
|
||||
simple_init_test: simple_init_test.c
|
||||
@echo "Building simple initialization test program (x86_64)..."
|
||||
|
|
@ -142,8 +148,13 @@ test-nip04: $(NIP04_TEST_EXEC)
|
|||
@echo "Running NIP-04 encryption tests (x86_64)..."
|
||||
./$(NIP04_TEST_EXEC)
|
||||
|
||||
# Run static linking verification test (x86_64)
|
||||
test-static-linking: $(STATIC_LINKING_TEST_EXEC)
|
||||
@echo "Running static linking verification test (x86_64)..."
|
||||
./$(STATIC_LINKING_TEST_EXEC)
|
||||
|
||||
# Run all test suites (x86_64)
|
||||
test: test-crypto test-core test-relay-pool test-nip04
|
||||
test: test-crypto test-core test-relay-pool test-nip04 test-static-linking
|
||||
|
||||
# Run crypto tests ARM64 (requires qemu-user-static or ARM64 system)
|
||||
test-crypto-arm64: $(ARM64_CRYPTO_TEST_EXEC)
|
||||
|
|
@ -190,7 +201,7 @@ test-all: test test-arm64
|
|||
# Clean
|
||||
clean:
|
||||
@echo "Cleaning test artifacts..."
|
||||
rm -f $(CRYPTO_TEST_EXEC) $(CORE_TEST_EXEC) $(RELAY_POOL_TEST_EXEC) $(EVENT_GEN_TEST_EXEC) $(POW_LOOP_TEST_EXEC) $(NIP04_TEST_EXEC) $(ARM64_CRYPTO_TEST_EXEC) $(ARM64_CORE_TEST_EXEC) $(ARM64_RELAY_POOL_TEST_EXEC) $(ARM64_NIP04_TEST_EXEC)
|
||||
rm -f $(CRYPTO_TEST_EXEC) $(CORE_TEST_EXEC) $(RELAY_POOL_TEST_EXEC) $(EVENT_GEN_TEST_EXEC) $(POW_LOOP_TEST_EXEC) $(NIP04_TEST_EXEC) $(STATIC_LINKING_TEST_EXEC) $(ARM64_CRYPTO_TEST_EXEC) $(ARM64_CORE_TEST_EXEC) $(ARM64_RELAY_POOL_TEST_EXEC) $(ARM64_NIP04_TEST_EXEC)
|
||||
|
||||
# Help
|
||||
help:
|
||||
|
|
@ -198,17 +209,18 @@ help:
|
|||
@echo "================"
|
||||
@echo ""
|
||||
@echo "Available targets:"
|
||||
@echo " all - Build all test executables (x86_64)"
|
||||
@echo " all-arch - Build test executables for both x86_64 and ARM64"
|
||||
@echo " test-crypto - Build and run crypto tests (x86_64)"
|
||||
@echo " test-core - Build and run core tests (x86_64)"
|
||||
@echo " test-relay-pool - Build and run relay pool tests (x86_64)"
|
||||
@echo " test-nip04 - Build and run NIP-04 encryption tests (x86_64)"
|
||||
@echo " test - Build and run all test suites (x86_64)"
|
||||
@echo " test-arm64 - Build and run all test suites (ARM64)"
|
||||
@echo " test-all - Run tests on both architectures"
|
||||
@echo " clean - Remove test artifacts"
|
||||
@echo " help - Show this help"
|
||||
@echo " all - Build all test executables (x86_64)"
|
||||
@echo " all-arch - Build test executables for both x86_64 and ARM64"
|
||||
@echo " test-crypto - Build and run crypto tests (x86_64)"
|
||||
@echo " test-core - Build and run core tests (x86_64)"
|
||||
@echo " test-relay-pool - Build and run relay pool tests (x86_64)"
|
||||
@echo " test-nip04 - Build and run NIP-04 encryption tests (x86_64)"
|
||||
@echo " test-static-linking - Build and run static linking verification test (x86_64)"
|
||||
@echo " test - Build and run all test suites (x86_64)"
|
||||
@echo " test-arm64 - Build and run all test suites (ARM64)"
|
||||
@echo " test-all - Run tests on both architectures"
|
||||
@echo " clean - Remove test artifacts"
|
||||
@echo " help - Show this help"
|
||||
@echo ""
|
||||
@echo "Test Executables:"
|
||||
@echo " $(CRYPTO_TEST_EXEC) - x86_64 crypto test binary"
|
||||
|
|
@ -221,9 +233,10 @@ help:
|
|||
@echo " $(ARM64_NIP04_TEST_EXEC) - ARM64 NIP-04 encryption test binary"
|
||||
@echo ""
|
||||
@echo "Test Coverage:"
|
||||
@echo " Crypto Tests - Low-level cryptographic primitives (SHA-256, HMAC, secp256k1, BIP39, BIP32)"
|
||||
@echo " Core Tests - High-level NOSTR functionality with nak compatibility validation"
|
||||
@echo " Relay Pool Tests - Relay pool event processing with real NOSTR relays"
|
||||
@echo " NIP-04 Tests - NOSTR NIP-04 encryption/decryption with reference test vectors"
|
||||
@echo " Crypto Tests - Low-level cryptographic primitives (SHA-256, HMAC, secp256k1, BIP39, BIP32)"
|
||||
@echo " Core Tests - High-level NOSTR functionality with nak compatibility validation"
|
||||
@echo " Relay Pool Tests - Relay pool event processing with real NOSTR relays"
|
||||
@echo " NIP-04 Tests - NOSTR NIP-04 encryption/decryption with reference test vectors"
|
||||
@echo " Static Linking Tests - Verify library has no external crypto dependencies (self-contained)"
|
||||
|
||||
.PHONY: all all-arch test-crypto test-core test-relay-pool test test-crypto-arm64 test-core-arm64 test-relay-pool-arm64 test-arm64 test-all clean help
|
||||
.PHONY: all all-arch test-crypto test-core test-relay-pool test-nip04 test-static-linking test test-crypto-arm64 test-core-arm64 test-relay-pool-arm64 test-arm64 test-all clean help
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -0,0 +1,416 @@
|
|||
/*
|
||||
* NOSTR Core Library - Static Linking Only Test
|
||||
*
|
||||
* This test verifies that the library maintains its self-contained,
|
||||
* static-only design with no external cryptographic dependencies.
|
||||
*
|
||||
* Test Categories:
|
||||
* 1. Library dependency analysis using ldd/otool
|
||||
* 2. Symbol resolution verification using nm/objdump
|
||||
* 3. Build process validation
|
||||
* 4. Runtime independence verification
|
||||
* 5. Library size and content verification
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE // For popen/pclose on Linux
|
||||
#include "../nostr_core/nostr_core.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/wait.h>
|
||||
#include <sys/stat.h>
|
||||
#include "../cjson/cJSON.h"
|
||||
|
||||
// ANSI color codes for output
|
||||
#define GREEN "\033[32m"
|
||||
#define RED "\033[31m"
|
||||
#define YELLOW "\033[33m"
|
||||
#define BLUE "\033[34m"
|
||||
#define RESET "\033[0m"
|
||||
|
||||
// Test result tracking
|
||||
static int tests_run = 0;
|
||||
static int tests_passed = 0;
|
||||
|
||||
// Helper function to run shell commands and capture output
|
||||
static int run_command(const char* command, char* output, size_t output_size) {
|
||||
FILE* fp = popen(command, "r");
|
||||
if (!fp) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
size_t total = 0;
|
||||
while (total < output_size - 1 && fgets(output + total, output_size - total, fp)) {
|
||||
total = strlen(output);
|
||||
}
|
||||
|
||||
int status = pclose(fp);
|
||||
return WEXITSTATUS(status);
|
||||
}
|
||||
|
||||
// Helper function to check if file exists
|
||||
static int file_exists(const char* path) {
|
||||
struct stat st;
|
||||
return stat(path, &st) == 0;
|
||||
}
|
||||
|
||||
// Test macro
|
||||
#define RUN_TEST(test_name, test_func) do { \
|
||||
printf(BLUE "[TEST] " RESET "%s...\n", test_name); \
|
||||
tests_run++; \
|
||||
if (test_func()) { \
|
||||
printf(GREEN "[PASS] " RESET "%s\n\n", test_name); \
|
||||
tests_passed++; \
|
||||
} else { \
|
||||
printf(RED "[FAIL] " RESET "%s\n\n", test_name); \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
// Test 1: Library Dependency Analysis
|
||||
static int test_library_dependency_analysis(void) {
|
||||
char command[512];
|
||||
char output[4096];
|
||||
int result;
|
||||
|
||||
// Check if we have the main library
|
||||
if (!file_exists("../libnostr_core.a")) {
|
||||
printf(RED "ERROR: " RESET "libnostr_core.a not found. Run 'make' first.\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Create a simple test binary to analyze
|
||||
printf("Creating test binary for dependency analysis...\n");
|
||||
|
||||
const char* test_code =
|
||||
"#include \"../nostr_core/nostr_core.h\"\n"
|
||||
"#include <stdio.h>\n"
|
||||
"int main() {\n"
|
||||
" if (nostr_init() == NOSTR_SUCCESS) {\n"
|
||||
" unsigned char privkey[32], pubkey[32];\n"
|
||||
" if (nostr_generate_keypair(privkey, pubkey) == NOSTR_SUCCESS) {\n"
|
||||
" printf(\"Crypto test passed\\n\");\n"
|
||||
" }\n"
|
||||
" nostr_cleanup();\n"
|
||||
" }\n"
|
||||
" return 0;\n"
|
||||
"}\n";
|
||||
|
||||
FILE* fp = fopen("/tmp/static_test.c", "w");
|
||||
if (!fp) {
|
||||
printf(RED "ERROR: " RESET "Cannot create temporary test file\n");
|
||||
return 0;
|
||||
}
|
||||
fputs(test_code, fp);
|
||||
fclose(fp);
|
||||
|
||||
// Compile the test binary
|
||||
snprintf(command, sizeof(command),
|
||||
"gcc -I.. -Wall -Wextra -std=c99 /tmp/static_test.c -o /tmp/static_test ../libnostr_core.a -lm -static 2>/dev/null");
|
||||
|
||||
result = system(command);
|
||||
if (result != 0) {
|
||||
printf(RED "ERROR: " RESET "Failed to compile test binary\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Analyze dependencies with ldd (Linux) or otool (macOS)
|
||||
printf("Analyzing binary dependencies...\n");
|
||||
|
||||
#ifdef __linux__
|
||||
snprintf(command, sizeof(command), "ldd /tmp/static_test 2>&1");
|
||||
#elif __APPLE__
|
||||
snprintf(command, sizeof(command), "otool -L /tmp/static_test 2>&1");
|
||||
#else
|
||||
printf(YELLOW "WARNING: " RESET "Unknown platform, skipping dependency analysis\n");
|
||||
cleanup_and_return:
|
||||
unlink("/tmp/static_test.c");
|
||||
unlink("/tmp/static_test");
|
||||
return 1;
|
||||
#endif
|
||||
|
||||
result = run_command(command, output, sizeof(output));
|
||||
|
||||
// Check for problematic dynamic dependencies
|
||||
const char* forbidden_libs[] = {
|
||||
"libsecp256k1",
|
||||
"libssl",
|
||||
"libcrypto",
|
||||
"libwally",
|
||||
"libsodium"
|
||||
};
|
||||
|
||||
int found_forbidden = 0;
|
||||
for (int i = 0; i < 5; i++) {
|
||||
if (strstr(output, forbidden_libs[i])) {
|
||||
printf(RED "ERROR: " RESET "Found forbidden dynamic dependency: %s\n", forbidden_libs[i]);
|
||||
found_forbidden = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found_forbidden) {
|
||||
printf(GREEN "GOOD: " RESET "No forbidden cryptographic dependencies found\n");
|
||||
}
|
||||
|
||||
// For static binaries, ldd should say "not a dynamic executable" or show minimal deps
|
||||
#ifdef __linux__
|
||||
if (strstr(output, "not a dynamic executable") || strstr(output, "statically linked")) {
|
||||
printf(GREEN "EXCELLENT: " RESET "Binary is statically linked\n");
|
||||
} else {
|
||||
printf(YELLOW "INFO: " RESET "Binary appears to have some dynamic dependencies:\n");
|
||||
printf("%s\n", output);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Cleanup
|
||||
unlink("/tmp/static_test.c");
|
||||
unlink("/tmp/static_test");
|
||||
|
||||
return !found_forbidden;
|
||||
}
|
||||
|
||||
// Test 2: Symbol Resolution Verification
|
||||
static int test_symbol_resolution_verification(void) {
|
||||
char command[512];
|
||||
char output[8192];
|
||||
|
||||
printf("Verifying secp256k1 symbols are present in static library...\n");
|
||||
|
||||
// Check that critical secp256k1 symbols are present
|
||||
snprintf(command, sizeof(command), "nm ../libnostr_core.a 2>/dev/null | grep secp256k1");
|
||||
|
||||
if (run_command(command, output, sizeof(output)) != 0 || strlen(output) == 0) {
|
||||
printf(RED "ERROR: " RESET "No secp256k1 symbols found in library\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Check for key secp256k1 functions
|
||||
const char* required_symbols[] = {
|
||||
"secp256k1_context_create",
|
||||
"secp256k1_ec_pubkey_create",
|
||||
"secp256k1_schnorrsig_sign",
|
||||
"secp256k1_schnorrsig_verify",
|
||||
"secp256k1_ecdh"
|
||||
};
|
||||
|
||||
int symbols_found = 0;
|
||||
for (int i = 0; i < 5; i++) {
|
||||
if (strstr(output, required_symbols[i])) {
|
||||
symbols_found++;
|
||||
printf(GREEN "FOUND: " RESET "%s\n", required_symbols[i]);
|
||||
} else {
|
||||
printf(YELLOW "MISSING: " RESET "%s\n", required_symbols[i]);
|
||||
}
|
||||
}
|
||||
|
||||
if (symbols_found >= 3) {
|
||||
printf(GREEN "GOOD: " RESET "Found %d/5 critical secp256k1 symbols\n", symbols_found);
|
||||
return 1;
|
||||
} else {
|
||||
printf(RED "ERROR: " RESET "Only found %d/5 critical secp256k1 symbols\n", symbols_found);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Test 3: Build Process Validation
|
||||
static int test_build_process_validation(void) {
|
||||
char command[512];
|
||||
int result;
|
||||
|
||||
printf("Testing minimal build requirements...\n");
|
||||
|
||||
// Test that we can build with only libnostr_core.a and -lm
|
||||
const char* minimal_test =
|
||||
"#include \"../nostr_core/nostr_core.h\"\n"
|
||||
"int main() { return nostr_init() == NOSTR_SUCCESS ? 0 : 1; }\n";
|
||||
|
||||
FILE* fp = fopen("/tmp/minimal_test.c", "w");
|
||||
if (!fp) return 0;
|
||||
fputs(minimal_test, fp);
|
||||
fclose(fp);
|
||||
|
||||
// Try to build with minimal dependencies
|
||||
snprintf(command, sizeof(command),
|
||||
"gcc -I.. -Wall -Wextra -std=c99 /tmp/minimal_test.c -o /tmp/minimal_test ../libnostr_core.a -lm 2>/dev/null");
|
||||
|
||||
result = system(command);
|
||||
|
||||
unlink("/tmp/minimal_test.c");
|
||||
|
||||
if (result == 0) {
|
||||
printf(GREEN "EXCELLENT: " RESET "Can build with only libnostr_core.a and -lm\n");
|
||||
|
||||
// Test that it actually runs
|
||||
result = system("/tmp/minimal_test");
|
||||
unlink("/tmp/minimal_test");
|
||||
|
||||
if (result == 0) {
|
||||
printf(GREEN "EXCELLENT: " RESET "Minimal binary runs successfully\n");
|
||||
return 1;
|
||||
} else {
|
||||
printf(RED "ERROR: " RESET "Minimal binary failed to run\n");
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
printf(RED "ERROR: " RESET "Cannot build with minimal dependencies\n");
|
||||
unlink("/tmp/minimal_test");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Test 4: Runtime Independence Test
|
||||
static int test_runtime_independence(void) {
|
||||
printf("Testing runtime independence (crypto functionality)...\n");
|
||||
|
||||
// Initialize the library
|
||||
if (nostr_init() != NOSTR_SUCCESS) {
|
||||
printf(RED "ERROR: " RESET "Library initialization failed\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Test key generation
|
||||
unsigned char private_key[32];
|
||||
unsigned char public_key[32];
|
||||
|
||||
if (nostr_generate_keypair(private_key, public_key) != NOSTR_SUCCESS) {
|
||||
printf(RED "ERROR: " RESET "Key generation failed\n");
|
||||
nostr_cleanup();
|
||||
return 0;
|
||||
}
|
||||
printf(GREEN "GOOD: " RESET "Key generation works\n");
|
||||
|
||||
// Test bech32 encoding
|
||||
char nsec[100], npub[100];
|
||||
if (nostr_key_to_bech32(private_key, "nsec", nsec) != NOSTR_SUCCESS ||
|
||||
nostr_key_to_bech32(public_key, "npub", npub) != NOSTR_SUCCESS) {
|
||||
printf(RED "ERROR: " RESET "Bech32 encoding failed\n");
|
||||
nostr_cleanup();
|
||||
return 0;
|
||||
}
|
||||
printf(GREEN "GOOD: " RESET "Bech32 encoding works\n");
|
||||
|
||||
// Test signing
|
||||
cJSON* event = nostr_create_and_sign_event(1, "Test message", NULL, private_key, 0);
|
||||
if (!event) {
|
||||
printf(RED "ERROR: " RESET "Event creation/signing failed\n");
|
||||
nostr_cleanup();
|
||||
return 0;
|
||||
}
|
||||
printf(GREEN "GOOD: " RESET "Event signing works\n");
|
||||
cJSON_Delete(event);
|
||||
|
||||
// Test NIP-44 encryption if available
|
||||
char plaintext[] = "Hello, NOSTR!";
|
||||
char encrypted[1024];
|
||||
char decrypted[1024];
|
||||
|
||||
// Generate recipient keys
|
||||
unsigned char recipient_private[32], recipient_public[32];
|
||||
nostr_generate_keypair(recipient_private, recipient_public);
|
||||
|
||||
if (nostr_nip44_encrypt(private_key, recipient_public, plaintext, encrypted, sizeof(encrypted)) == NOSTR_SUCCESS) {
|
||||
if (nostr_nip44_decrypt(recipient_private, public_key, encrypted, decrypted, sizeof(decrypted)) == NOSTR_SUCCESS) {
|
||||
if (strcmp(plaintext, decrypted) == 0) {
|
||||
printf(GREEN "EXCELLENT: " RESET "NIP-44 encryption/decryption works\n");
|
||||
} else {
|
||||
printf(YELLOW "WARNING: " RESET "NIP-44 decryption mismatch\n");
|
||||
}
|
||||
} else {
|
||||
printf(YELLOW "WARNING: " RESET "NIP-44 decryption failed\n");
|
||||
}
|
||||
} else {
|
||||
printf(YELLOW "WARNING: " RESET "NIP-44 encryption failed (may not be enabled)\n");
|
||||
}
|
||||
|
||||
nostr_cleanup();
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Test 5: Library Size and Content Verification
|
||||
static int test_library_size_and_content(void) {
|
||||
struct stat st;
|
||||
char command[512];
|
||||
char output[4096];
|
||||
|
||||
printf("Verifying library size and content...\n");
|
||||
|
||||
// Check library size
|
||||
if (stat("../libnostr_core.a", &st) != 0) {
|
||||
printf(RED "ERROR: " RESET "Cannot stat libnostr_core.a\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t lib_size = st.st_size;
|
||||
printf("Library size: %zu bytes (%.2f MB)\n", lib_size, lib_size / 1024.0 / 1024.0);
|
||||
|
||||
// Expect "fat" library to be at least 1MB (with secp256k1 bundled)
|
||||
if (lib_size < 1024 * 1024) {
|
||||
printf(YELLOW "WARNING: " RESET "Library seems small (%.2f MB). May not include secp256k1.\n",
|
||||
lib_size / 1024.0 / 1024.0);
|
||||
} else {
|
||||
printf(GREEN "GOOD: " RESET "Library size suggests secp256k1 is bundled\n");
|
||||
}
|
||||
|
||||
// List archive contents
|
||||
snprintf(command, sizeof(command), "ar -t ../libnostr_core.a | wc -l");
|
||||
if (run_command(command, output, sizeof(output)) == 0) {
|
||||
int object_count = atoi(output);
|
||||
printf("Archive contains %d object files\n", object_count);
|
||||
|
||||
if (object_count > 20) {
|
||||
printf(GREEN "EXCELLENT: " RESET "High object count suggests secp256k1 objects included\n");
|
||||
} else {
|
||||
printf(YELLOW "WARNING: " RESET "Low object count (%d). secp256k1 may not be fully bundled\n", object_count);
|
||||
}
|
||||
}
|
||||
|
||||
// Check for secp256k1-specific object files
|
||||
snprintf(command, sizeof(command), "ar -t ../libnostr_core.a | grep -E '(secp256k1|ecmult)' | head -5");
|
||||
if (run_command(command, output, sizeof(output)) == 0 && strlen(output) > 0) {
|
||||
printf(GREEN "EXCELLENT: " RESET "Found secp256k1 object files in archive:\n");
|
||||
printf("%s", output);
|
||||
} else {
|
||||
printf(YELLOW "WARNING: " RESET "No obvious secp256k1 object files found\n");
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Main test runner
|
||||
int main(int argc, char* argv[]) {
|
||||
(void)argc;
|
||||
(void)argv;
|
||||
|
||||
printf(BLUE "NOSTR Core Library - Static Linking Only Test\n");
|
||||
printf("==============================================" RESET "\n\n");
|
||||
|
||||
printf("This test verifies that the library maintains its self-contained,\n");
|
||||
printf("static-only design with no external cryptographic dependencies.\n\n");
|
||||
|
||||
// Run all tests
|
||||
RUN_TEST("Library Dependency Analysis", test_library_dependency_analysis);
|
||||
RUN_TEST("Symbol Resolution Verification", test_symbol_resolution_verification);
|
||||
RUN_TEST("Build Process Validation", test_build_process_validation);
|
||||
RUN_TEST("Runtime Independence Test", test_runtime_independence);
|
||||
RUN_TEST("Library Size and Content Verification", test_library_size_and_content);
|
||||
|
||||
// Print summary
|
||||
printf(BLUE "============================================\n");
|
||||
printf("TEST SUMMARY\n");
|
||||
printf("============================================" RESET "\n");
|
||||
printf("Tests run: %d\n", tests_run);
|
||||
printf("Tests passed: %d\n", tests_passed);
|
||||
|
||||
if (tests_passed == tests_run) {
|
||||
printf(GREEN "ALL TESTS PASSED!" RESET "\n");
|
||||
printf("✅ Library maintains static-only design\n");
|
||||
printf("✅ No external crypto dependencies\n");
|
||||
printf("✅ Self-contained and portable\n");
|
||||
} else {
|
||||
printf(RED "SOME TESTS FAILED!" RESET "\n");
|
||||
printf("❌ %d out of %d tests failed\n", tests_run - tests_passed, tests_run);
|
||||
printf("⚠️ Library may have external dependencies or missing components\n");
|
||||
}
|
||||
|
||||
return (tests_passed == tests_run) ? 0 : 1;
|
||||
}
|
||||
Loading…
Reference in New Issue