mirror of
https://github.com/kerberos-io/agent.git
synced 2026-11-21 22:50:39 +00:00
Compare commits
18
Commits
@@ -1,9 +1,5 @@
|
||||
FROM mcr.microsoft.com/devcontainers/go:1.26-trixie
|
||||
|
||||
# Same pin as the main Dockerfile: Go 1.26.11 rejects moq-go-ffi v0.3.x's
|
||||
# archives (LLVM bitcode), which breaks `go build -tags moq`.
|
||||
ENV GOTOOLCHAIN=go1.26.10
|
||||
|
||||
# Install node environment
|
||||
RUN apt-get update && \
|
||||
apt-get install -y --no-install-recommends \
|
||||
|
||||
@@ -22,10 +22,12 @@ env:
|
||||
jobs:
|
||||
# Determine the next version, create the GitHub release and expose the tag.
|
||||
bump-release:
|
||||
uses: uug-ai/workflows/.github/workflows/release-bump.yml@main
|
||||
# Pinned to a reviewed commit of uug-ai/workflows so changes there cannot
|
||||
# alter this release without a change here. It only needs GITHUB_TOKEN,
|
||||
# which GitHub provides to called workflows, so no secrets are passed on.
|
||||
uses: uug-ai/workflows/.github/workflows/release-bump.yml@6c1805abf25ac34add01d4af711277e8a68945ab # main as of 2026-11-20
|
||||
with:
|
||||
bump: ${{ github.event.inputs.bump }}
|
||||
secrets: inherit
|
||||
|
||||
# Publish the platform image to the uug-ai GitHub Container Registry
|
||||
# (ghcr.io/uug-ai/agent-platform).
|
||||
@@ -56,6 +58,9 @@ jobs:
|
||||
strategy:
|
||||
matrix:
|
||||
architecture: [amd64]
|
||||
env:
|
||||
ARCH: ${{ matrix.architecture }}
|
||||
RELEASE_TAG: ${{ needs.bump-release.outputs.tag }}
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
@@ -66,16 +71,16 @@ jobs:
|
||||
uses: actions/checkout@v4
|
||||
- name: Run Build
|
||||
run: |
|
||||
docker build --provenance=false --build-arg VERSION=${{ needs.bump-release.outputs.tag }} -t ${{matrix.architecture}} .
|
||||
CID=$(docker create ${{matrix.architecture}})
|
||||
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
|
||||
docker rm ${CID}
|
||||
docker build --provenance=false --build-arg VERSION="${RELEASE_TAG}" -t "${ARCH}" .
|
||||
CID=$(docker create "${ARCH}")
|
||||
docker cp "${CID}:/home/agent" "./output-${ARCH}"
|
||||
docker rm "${CID}"
|
||||
- name: Strip binary
|
||||
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
|
||||
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
|
||||
- name: Build and push Docker image
|
||||
run: |
|
||||
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
|
||||
docker push $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
|
||||
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
|
||||
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
@@ -90,6 +95,9 @@ jobs:
|
||||
strategy:
|
||||
matrix:
|
||||
architecture: [arm64]
|
||||
env:
|
||||
ARCH: ${{ matrix.architecture }}
|
||||
RELEASE_TAG: ${{ needs.bump-release.outputs.tag }}
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
@@ -100,16 +108,16 @@ jobs:
|
||||
uses: actions/checkout@v4
|
||||
- name: Run Build
|
||||
run: |
|
||||
docker build --provenance=false --build-arg VERSION=${{ needs.bump-release.outputs.tag }} -t ${{matrix.architecture}} .
|
||||
CID=$(docker create ${{matrix.architecture}})
|
||||
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
|
||||
docker rm ${CID}
|
||||
docker build --provenance=false --build-arg VERSION="${RELEASE_TAG}" -t "${ARCH}" .
|
||||
CID=$(docker create "${ARCH}")
|
||||
docker cp "${CID}:/home/agent" "./output-${ARCH}"
|
||||
docker rm "${CID}"
|
||||
- name: Strip binary
|
||||
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
|
||||
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
|
||||
- name: Build and push Docker image
|
||||
run: |
|
||||
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
|
||||
docker push $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
|
||||
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
|
||||
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
@@ -119,6 +127,8 @@ jobs:
|
||||
create-manifest:
|
||||
runs-on: ubuntu-24.04
|
||||
needs: [bump-release, build-amd64, build-arm64]
|
||||
env:
|
||||
RELEASE_TAG: ${{ needs.bump-release.outputs.tag }}
|
||||
steps:
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
@@ -127,16 +137,16 @@ jobs:
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Create and push multi-arch manifest
|
||||
run: |
|
||||
docker manifest create $REPO:${{ needs.bump-release.outputs.tag }} \
|
||||
$REPO-arch:arch-amd64-${{ needs.bump-release.outputs.tag }} \
|
||||
$REPO-arch:arch-arm64-${{ needs.bump-release.outputs.tag }}
|
||||
docker manifest push $REPO:${{ needs.bump-release.outputs.tag }}
|
||||
docker manifest create "${REPO}:${RELEASE_TAG}" \
|
||||
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
|
||||
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
|
||||
docker manifest push "${REPO}:${RELEASE_TAG}"
|
||||
- name: Create and push latest manifest
|
||||
run: |
|
||||
docker manifest create $REPO:latest \
|
||||
$REPO-arch:arch-amd64-${{ needs.bump-release.outputs.tag }} \
|
||||
$REPO-arch:arch-arm64-${{ needs.bump-release.outputs.tag }}
|
||||
docker manifest push $REPO:latest
|
||||
docker manifest create "${REPO}:latest" \
|
||||
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
|
||||
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
|
||||
docker manifest push "${REPO}:latest"
|
||||
|
||||
create-release:
|
||||
runs-on: ubuntu-24.04
|
||||
|
||||
@@ -11,6 +11,9 @@ on:
|
||||
|
||||
env:
|
||||
REPO: kerberos/agent
|
||||
# Expressions are passed to shell steps through the environment and quoted,
|
||||
# never interpolated into the script, so a crafted tag cannot inject commands.
|
||||
RELEASE_TAG: ${{ github.event.inputs.tag || github.ref_name }}
|
||||
|
||||
jobs:
|
||||
build-amd64:
|
||||
@@ -20,7 +23,15 @@ jobs:
|
||||
strategy:
|
||||
matrix:
|
||||
architecture: [amd64]
|
||||
env:
|
||||
ARCH: ${{ matrix.architecture }}
|
||||
steps:
|
||||
- name: Validate release tag
|
||||
run: |
|
||||
if [[ ! "${RELEASE_TAG}" =~ ^[A-Za-z0-9._-]+$ ]]; then
|
||||
echo "Invalid release tag: only letters, digits, '.', '_' and '-' are allowed." >&2
|
||||
exit 1
|
||||
fi
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
@@ -30,16 +41,16 @@ jobs:
|
||||
uses: actions/checkout@v4
|
||||
- name: Run Build
|
||||
run: |
|
||||
docker build --provenance=false --build-arg VERSION=${{github.event.inputs.tag || github.ref_name}} -t ${{matrix.architecture}} .
|
||||
CID=$(docker create ${{matrix.architecture}})
|
||||
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
|
||||
docker rm ${CID}
|
||||
docker build --provenance=false --build-arg VERSION="${RELEASE_TAG}" -t "${ARCH}" .
|
||||
CID=$(docker create "${ARCH}")
|
||||
docker cp "${CID}:/home/agent" "./output-${ARCH}"
|
||||
docker rm "${CID}"
|
||||
- name: Strip binary
|
||||
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
|
||||
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
|
||||
- name: Build and push Docker image
|
||||
run: |
|
||||
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
|
||||
docker push $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
|
||||
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
|
||||
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
@@ -53,7 +64,15 @@ jobs:
|
||||
strategy:
|
||||
matrix:
|
||||
architecture: [arm64]
|
||||
env:
|
||||
ARCH: ${{ matrix.architecture }}
|
||||
steps:
|
||||
- name: Validate release tag
|
||||
run: |
|
||||
if [[ ! "${RELEASE_TAG}" =~ ^[A-Za-z0-9._-]+$ ]]; then
|
||||
echo "Invalid release tag: only letters, digits, '.', '_' and '-' are allowed." >&2
|
||||
exit 1
|
||||
fi
|
||||
- name: Login to DockerHub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
@@ -63,16 +82,16 @@ jobs:
|
||||
uses: actions/checkout@v4
|
||||
- name: Run Build
|
||||
run: |
|
||||
docker build --provenance=false --build-arg VERSION=${{github.event.inputs.tag || github.ref_name}} -t ${{matrix.architecture}} .
|
||||
CID=$(docker create ${{matrix.architecture}})
|
||||
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
|
||||
docker rm ${CID}
|
||||
docker build --provenance=false --build-arg VERSION="${RELEASE_TAG}" -t "${ARCH}" .
|
||||
CID=$(docker create "${ARCH}")
|
||||
docker cp "${CID}:/home/agent" "./output-${ARCH}"
|
||||
docker rm "${CID}"
|
||||
- name: Strip binary
|
||||
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
|
||||
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
|
||||
- name: Build and push Docker image
|
||||
run: |
|
||||
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
|
||||
docker push $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
|
||||
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
|
||||
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
@@ -90,16 +109,16 @@ jobs:
|
||||
password: ${{ secrets.DOCKER_PASSWORD }}
|
||||
- name: Create and push multi-arch manifest
|
||||
run: |
|
||||
docker manifest create $REPO:${{ github.event.inputs.tag || github.ref_name }} \
|
||||
$REPO-arch:arch-amd64-${{github.event.inputs.tag || github.ref_name}} \
|
||||
$REPO-arch:arch-arm64-${{github.event.inputs.tag || github.ref_name}}
|
||||
docker manifest push $REPO:${{ github.event.inputs.tag || github.ref_name }}
|
||||
docker manifest create "${REPO}:${RELEASE_TAG}" \
|
||||
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
|
||||
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
|
||||
docker manifest push "${REPO}:${RELEASE_TAG}"
|
||||
- name: Create and push latest manifest
|
||||
run: |
|
||||
docker manifest create $REPO:latest \
|
||||
$REPO-arch:arch-amd64-${{github.event.inputs.tag || github.ref_name}} \
|
||||
$REPO-arch:arch-arm64-${{github.event.inputs.tag || github.ref_name}}
|
||||
docker manifest push $REPO:latest
|
||||
docker manifest create "${REPO}:latest" \
|
||||
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
|
||||
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
|
||||
docker manifest push "${REPO}:latest"
|
||||
if: github.event.inputs.tag == 'test'
|
||||
|
||||
create-release:
|
||||
|
||||
+1
-4
@@ -1,8 +1,5 @@
|
||||
|
||||
# Pinned to 1.26.10: Go 1.26.11 rejects C archives containing LLVM bitcode
|
||||
# ("disallowed LTO section .llvmbc"), and moq-go-ffi v0.3.x ships such archives.
|
||||
# Unpin once the MoQ code moves to moq.dev/moq (moq-ffi v0.4.27+ is clean).
|
||||
ARG GO_IMAGE=golang:1.26.10-trixie
|
||||
ARG GO_IMAGE=golang:1.26-trixie
|
||||
ARG RUNTIME_IMAGE=debian:trixie-slim
|
||||
ARG VERSION=0.0.0
|
||||
FROM ${GO_IMAGE} AS build-machinery
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
# Recording file structure
|
||||
|
||||
This document describes where the Kerberos Agent stores recordings, locally and in
|
||||
direct S3 uploads, and how the current layout relates to the legacy one.
|
||||
|
||||
## Local recording layout
|
||||
|
||||
New local recordings are stored under
|
||||
`data/recordings/yyyy/mm/dd/<timestamp>-<deviceKey>.mp4`, using the recording's UTC
|
||||
start date and Unix-millisecond timestamp. For example:
|
||||
`data/recordings/2026/01/02/1767355200123-device-key.mp4`.
|
||||
The filename no longer embeds the camera name, region, change count, or duration,
|
||||
and it does not change when the recording is finalized.
|
||||
Those attributes, together with FPS and encryption status, are captured in the
|
||||
`.metadata` upload checkpoint and sent as structured HTTP/tus metadata.
|
||||
|
||||
Existing flat recordings and dated recordings with older long filenames remain
|
||||
supported without a migration. Recording lists, day filters, playback, uploaders,
|
||||
and automatic cleanup handle both filename formats and layouts. Upload queue
|
||||
checkpoints remain flat in `data/cloud/`. Successful-upload removal also resolves
|
||||
both local layouts. Deploy the updated Vault alongside Agent for canonical
|
||||
`<account-directory>/yyyy/mm/dd/<timestamp>-<deviceKey>.mp4` storage keys and
|
||||
metadata-driven Hub integration events.
|
||||
Directory decryption also processes dated subdirectories and writes each output
|
||||
to a sibling `decrypted/` directory; those outputs are excluded from recording
|
||||
lists and automatic cleanup.
|
||||
|
||||
## Direct S3 recording layout
|
||||
|
||||
Direct S3 uploads store recordings as
|
||||
`<s3.username>/yyyy/mm/dd/<timestamp>-<deviceKey>.mp4`. The timestamp is the
|
||||
recording's Unix timestamp in milliseconds, and the date is its UTC date, not the upload
|
||||
date. Timestamp and device key come from the recording's `.metadata` upload
|
||||
checkpoint, which stores the timestamp in milliseconds. The uploader also
|
||||
preserves checkpoint duration, FPS (when available), and encryption status as S3
|
||||
object metadata. The device key must be non-empty and contain no path separators.
|
||||
Retried uploads use the same object key, even after midnight. Millisecond
|
||||
precision keeps recordings starting within the same second distinct.
|
||||
|
||||
This replaces the previous `<s3.username>/<filename>.mp4` layout for new uploads.
|
||||
Existing objects are not moved; consumers of direct S3 uploads must support both
|
||||
layouts when reading historical recordings. Updated Kerberos Vault deployments
|
||||
use the same filename and dated layout under the authenticated account directory
|
||||
for both direct Vault uploads and Hub-proxied uploads.
|
||||
|
||||
Only historical recordings with missing, empty, or FPS-only queue markers fall
|
||||
back to the legacy filename format and configured Agent key. A structured
|
||||
checkpoint takes precedence over both the filename and current configured key;
|
||||
an invalid or unreadable checkpoint is reported as an upload error, not silently
|
||||
replaced with filename-derived values.
|
||||
For older structured checkpoints, missing camera name, region, and change count
|
||||
are recovered from a validated legacy filename. Populated checkpoint fields
|
||||
take precedence, and the checkpoint timestamp and device key remain authoritative.
|
||||
|
||||
The shorter filename cannot be decoded by legacy filename-only consumers.
|
||||
Integrations must preserve structured recording metadata, including the device
|
||||
key (`productid`) and recording timestamp (`event-timestamp`), as well as the full
|
||||
object key.
|
||||
@@ -61,6 +61,7 @@ There are a myriad of cameras out there (USB, IP and other cameras), and it migh
|
||||
|
||||
1. [Encryption](#encryption)
|
||||
2. [H264 vs H265](#h264-vs-h265)
|
||||
3. [Recording file structure](README-FILE-STRUCTURE.md)
|
||||
|
||||
### Contributing
|
||||
|
||||
@@ -76,60 +77,6 @@ There are a myriad of cameras out there (USB, IP and other cameras), and it migh
|
||||
1. [What is new?](#what-is-new)
|
||||
1. [Contributors](#contributors)
|
||||
|
||||
### Direct S3 recording layout
|
||||
|
||||
Direct S3 uploads store recordings as
|
||||
`<s3.username>/yyyy/mm/dd/<timestamp>-<deviceKey>.mp4`. The timestamp is the
|
||||
recording's Unix timestamp in milliseconds, and the date is its UTC date, not the upload
|
||||
date. Timestamp and device key come from the recording's `.metadata` upload
|
||||
checkpoint, which stores the timestamp in milliseconds. The uploader also
|
||||
preserves checkpoint duration, FPS (when available), and encryption status as S3
|
||||
object metadata. The device key must be non-empty and contain no path separators.
|
||||
Retried uploads use the same object key, even after midnight. Millisecond
|
||||
precision keeps recordings starting within the same second distinct.
|
||||
|
||||
This replaces the previous `<s3.username>/<filename>.mp4` layout for new uploads.
|
||||
Existing objects are not moved; consumers of direct S3 uploads must support both
|
||||
layouts when reading historical recordings. Updated Kerberos Vault deployments
|
||||
use the same filename and dated layout under the authenticated account directory
|
||||
for both direct Vault uploads and Hub-proxied uploads.
|
||||
|
||||
Only historical recordings with missing, empty, or FPS-only queue markers fall
|
||||
back to the legacy filename format and configured Agent key. A structured
|
||||
checkpoint takes precedence over both the filename and current configured key;
|
||||
an invalid or unreadable checkpoint is reported as an upload error, not silently
|
||||
replaced with filename-derived values.
|
||||
For older structured checkpoints, missing camera name, region, and change count
|
||||
are recovered from a validated legacy filename. Populated checkpoint fields
|
||||
take precedence, and the checkpoint timestamp and device key remain authoritative.
|
||||
|
||||
The shorter filename cannot be decoded by legacy filename-only consumers.
|
||||
Integrations must preserve structured recording metadata, including the device
|
||||
key (`productid`) and recording timestamp (`event-timestamp`), as well as the full
|
||||
object key.
|
||||
|
||||
### Local recording layout
|
||||
|
||||
New local recordings are stored under
|
||||
`data/recordings/yyyy/mm/dd/<timestamp>-<deviceKey>.mp4`, using the recording's UTC
|
||||
start date and Unix-millisecond timestamp. For example:
|
||||
`data/recordings/2026/01/02/1767355200123-device-key.mp4`.
|
||||
The filename no longer embeds the camera name, region, change count, or duration,
|
||||
and it does not change when the recording is finalized.
|
||||
Those attributes, together with FPS and encryption status, are captured in the
|
||||
`.metadata` upload checkpoint and sent as structured HTTP/tus metadata.
|
||||
|
||||
Existing flat recordings and dated recordings with older long filenames remain
|
||||
supported without a migration. Recording lists, day filters, playback, uploaders,
|
||||
and automatic cleanup handle both filename formats and layouts. Upload queue
|
||||
checkpoints remain flat in `data/cloud/`. Successful-upload removal also resolves
|
||||
both local layouts. Deploy the updated Vault alongside Agent for canonical
|
||||
`<account-directory>/yyyy/mm/dd/<timestamp>-<deviceKey>.mp4` storage keys and
|
||||
metadata-driven Hub integration events.
|
||||
Directory decryption also processes dated subdirectories and writes each output
|
||||
to a sibling `decrypted/` directory; those outputs are excluded from recording
|
||||
lists and automatic cleanup.
|
||||
|
||||
## Quickstart - Docker
|
||||
|
||||
The easiest way to get your Kerberos Agent up and running is to use our public image on [Docker hub](https://hub.docker.com/r/kerberos/agent). Once you have selected a specific tag, run `docker` command below, which will open the web interface of your Kerberos agent on port `80`, and off you go. For a more configurable and persistent deployment have a look at [Running and automating a Kerberos Agent](#running-and-automating-a-kerberos-agent).
|
||||
@@ -354,6 +301,22 @@ For a private CA, mount a PEM trust bundle containing every CA certificate neede
|
||||
|
||||
See [RTSPS and TLS certificates](README-RTSPS-TLS.md) for the complete Bosch UI, private-CA, deployment, validation, and troubleshooting procedure.
|
||||
|
||||
### RTSP transport (TCP, UDP or auto)
|
||||
|
||||
`AGENT_CAPTURE_IPCAMERA_RTSP_TRANSPORT` (or the transport dropdown in Settings) selects how RTP media is received from the camera:
|
||||
|
||||
- `tcp` (default): media is interleaved on the RTSP TCP connection. Most reliable, works through any NAT or firewall.
|
||||
- `udp`: media is sent over separate UDP ports. Lower latency, but lost packets are not resent.
|
||||
- `auto`: UDP first, falling back to TCP when the camera refuses UDP or no UDP packets arrive within 3 seconds.
|
||||
|
||||
Notes:
|
||||
|
||||
- With `rtsps://` URLs, `udp` only works when the camera offers SRTP. Otherwise the connection fails with a message pointing to `tcp` or `auto`. `auto` uses TCP for such cameras on its own.
|
||||
- The audio backchannel (talk-back) always uses TCP.
|
||||
- For UDP the Agent requests a 4 MiB socket receive buffer, capped at the host's `net.core.rmem_max` (often about 208 KiB). For high-bitrate main streams, raise the limit on the host, for example `sysctl -w net.core.rmem_max=4194304`. Lost packets are logged as `rtp_packets_lost`.
|
||||
- UDP needs the camera's RTP packets to reach the Agent. Docker bridge networking normally works; if a firewall or Kubernetes network policy drops them, use `auto` or `tcp`.
|
||||
- The transport the Agent ended up with is logged as `rtsp_transport` (and `rtsp_transport_switch` when `auto` falls back to TCP).
|
||||
|
||||
| Name | Description | Default Value |
|
||||
| --------------------------------------- | ----------------------------------------------------------------------------------------------- | ------------------------------ |
|
||||
| `LOG_LEVEL` | Level for logging, could be "info", "warning", "debug", "error" or "fatal". | "info" |
|
||||
@@ -375,6 +338,7 @@ See [RTSPS and TLS certificates](README-RTSPS-TLS.md) for the complete Bosch UI,
|
||||
| `AGENT_TIMETABLE` | A (weekly) time table to specify when to make recordings "start1,end1,start2,end2;start1.. | "" |
|
||||
| `AGENT_REGION_POLYGON` | A single polygon set for motion detection: "x1,y1;x2,y2;x3,y3;... | "" |
|
||||
| `AGENT_CAPTURE_IPCAMERA_RTSP` | Full-HD RTSP or RTSPS endpoint for the target camera. | "" |
|
||||
| `AGENT_CAPTURE_IPCAMERA_RTSP_TRANSPORT` | Transport for the RTSP streams: "tcp", "udp" or "auto" (UDP first, falls back to TCP). | "tcp" |
|
||||
| `AGENT_CAPTURE_IPCAMERA_SUB_RTSP` | RTSP or RTSPS sub-stream endpoint used for livestreaming (WebRTC). | "" |
|
||||
| `AGENT_CAPTURE_IPCAMERA_RTSPS_CA_FILE` | PEM CA bundle appended to the system roots for RTSPS camera certificate verification. | "" |
|
||||
| `AGENT_CAPTURE_IPCAMERA_RTSPS_INSECURE` | Disable RTSPS camera certificate verification; use only when a trusted CA cannot be installed. | "false" |
|
||||
|
||||
+2
-2
@@ -27,7 +27,6 @@ require (
|
||||
github.com/kerberos-io/joy4 v1.0.64
|
||||
github.com/kerberos-io/onvif v1.2.3
|
||||
github.com/minio/minio-go/v6 v6.0.57
|
||||
github.com/moq-dev/moq-go v0.5.7
|
||||
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
|
||||
github.com/pion/interceptor v0.1.47
|
||||
github.com/pion/rtcp v1.2.17
|
||||
@@ -47,6 +46,7 @@ require (
|
||||
go.opentelemetry.io/otel/sdk v1.47.0
|
||||
go.opentelemetry.io/otel/trace v1.47.0
|
||||
golang.org/x/net v0.62.0
|
||||
moq.dev/moq v0.7.27
|
||||
)
|
||||
|
||||
require (
|
||||
@@ -99,7 +99,6 @@ require (
|
||||
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
|
||||
github.com/modern-go/reflect2 v1.0.2 // indirect
|
||||
github.com/montanaflynn/stats v0.7.1 // indirect
|
||||
github.com/moq-dev/moq-go-ffi v0.3.7 // indirect
|
||||
github.com/nxadm/tail v1.4.11 // indirect
|
||||
github.com/pelletier/go-toml/v2 v2.2.3 // indirect
|
||||
github.com/pion/datachannel v1.6.2 // indirect
|
||||
@@ -143,4 +142,5 @@ require (
|
||||
gopkg.in/ini.v1 v1.42.0 // indirect
|
||||
gopkg.in/yaml.v3 v3.0.1 // indirect
|
||||
howett.net/plist v0.0.0-20181124034731-591f970eefbb // indirect
|
||||
moq.dev/moq-ffi v0.4.27 // indirect
|
||||
)
|
||||
|
||||
+4
-4
@@ -857,10 +857,6 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
|
||||
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
|
||||
github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE=
|
||||
github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
|
||||
github.com/moq-dev/moq-go v0.5.7 h1:LfFpgAU8FRMcnU85L5Lb03HzxhYbQ2+BhT/pJQdjy5U=
|
||||
github.com/moq-dev/moq-go v0.5.7/go.mod h1:5K8zjKKjWe5lzfCtlfxoAfdCr3KX6EBuTOZsz0WBnzw=
|
||||
github.com/moq-dev/moq-go-ffi v0.3.7 h1:+xwPOzTJHvB0tuTnW6znbvvOgT4yLnN7sMqXXZYh02M=
|
||||
github.com/moq-dev/moq-go-ffi v0.3.7/go.mod h1:zxpOlUetvaoxWBnbXTdILtLLUytaoVuLvO36lftwWO0=
|
||||
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
|
||||
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
|
||||
github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY=
|
||||
@@ -2174,6 +2170,10 @@ modernc.org/tcl v1.15.1/go.mod h1:aEjeGJX2gz1oWKOLDVZ2tnEWLUrIn8H+GFu+akoDhqs=
|
||||
modernc.org/token v1.0.1/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
|
||||
modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
|
||||
modernc.org/z v1.7.0/go.mod h1:hVdgNMh8ggTuRG1rGU8x+xGRFfiQUIAw0ZqlPy8+HyQ=
|
||||
moq.dev/moq v0.7.27 h1:MICXMveLyoFBPj6Tu10oLH8NMhkYaDOa7oe6ay0RQ/c=
|
||||
moq.dev/moq v0.7.27/go.mod h1:zdCa+pXvmwXg+qTXgVJzO9jX7GbI7R/AFGwWOx1BKg0=
|
||||
moq.dev/moq-ffi v0.4.27 h1:PCXoyW1QTUN2XnM4pkAIBGpOAFjhm1OmCyPfPHszKPc=
|
||||
moq.dev/moq-ffi v0.4.27/go.mod h1:a+uEvcnNtY3e9T4/3UqjHBnyYHNLY8rZp+/m7tmL5n8=
|
||||
nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
|
||||
rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
|
||||
rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
|
||||
|
||||
@@ -32,6 +32,7 @@ import (
|
||||
"github.com/bluenviron/gortsplib/v5/pkg/format/rtplpcm"
|
||||
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmpeg4audio"
|
||||
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpsimpleaudio"
|
||||
"github.com/bluenviron/gortsplib/v5/pkg/headers"
|
||||
"github.com/bluenviron/mediacommon/pkg/bits"
|
||||
"github.com/bluenviron/mediacommon/pkg/codecs/h264"
|
||||
"github.com/bluenviron/mediacommon/pkg/codecs/h265"
|
||||
@@ -50,6 +51,104 @@ const (
|
||||
rtspsInsecureEnv = "AGENT_CAPTURE_IPCAMERA_RTSPS_INSECURE"
|
||||
)
|
||||
|
||||
// RTSP transport options for the camera connection.
|
||||
const (
|
||||
RTSPTransportTCP = "tcp"
|
||||
RTSPTransportUDP = "udp"
|
||||
RTSPTransportAuto = "auto"
|
||||
)
|
||||
|
||||
// rtspProtocol maps the configured RTSP transport onto the gortsplib client
|
||||
// protocol. An empty value keeps the historical default (TCP). "auto" returns
|
||||
// nil, which lets gortsplib try UDP first and fall back to TCP when the camera
|
||||
// or the network does not support it. Unknown values fall back to TCP.
|
||||
func rtspProtocol(transport string) *gortsplib.Protocol {
|
||||
var protocol gortsplib.Protocol
|
||||
switch strings.ToLower(strings.TrimSpace(transport)) {
|
||||
case "", RTSPTransportTCP:
|
||||
protocol = gortsplib.ProtocolTCP
|
||||
case RTSPTransportUDP:
|
||||
protocol = gortsplib.ProtocolUDP
|
||||
case RTSPTransportAuto:
|
||||
return nil
|
||||
default:
|
||||
log.Warn("capture.golibrtsp.rtspProtocol(): unknown RTSP transport \"" + transport + "\", falling back to tcp")
|
||||
protocol = gortsplib.ProtocolTCP
|
||||
}
|
||||
return &protocol
|
||||
}
|
||||
|
||||
// backChannelProtocol is the transport used for the audio backchannel. It is
|
||||
// always TCP: gortsplib's "auto" fallback only switches to TCP when no packets
|
||||
// are received over UDP, which never happens on a send-only backchannel, and
|
||||
// talk-back over UDP has not been validated on camera hardware.
|
||||
func backChannelProtocol() *gortsplib.Protocol {
|
||||
protocol := gortsplib.ProtocolTCP
|
||||
return &protocol
|
||||
}
|
||||
|
||||
// errSecureUDPUnavailable is returned when UDP is forced on an RTSPS camera
|
||||
// that does not offer SRTP, so the media could not be sent encrypted over UDP.
|
||||
var errSecureUDPUnavailable = errors.New(
|
||||
"the RTSPS camera does not offer SRTP, so RTP over UDP cannot be encrypted; " +
|
||||
"set the RTSP transport to \"tcp\" or \"auto\"")
|
||||
|
||||
// checkSecureUDP rejects forced UDP on an RTSPS stream whose video media is not
|
||||
// SRTP (RTP/SAVP). gortsplib would otherwise fail every SETUP with "unable to
|
||||
// setup secure UDP", which Connect only logs. "auto" is not affected because
|
||||
// gortsplib picks TCP on its own for such streams.
|
||||
func checkSecureUDP(scheme string, protocol *gortsplib.Protocol, medias []*description.Media) error {
|
||||
if protocol == nil || *protocol != gortsplib.ProtocolUDP || !strings.EqualFold(scheme, "rtsps") {
|
||||
return nil
|
||||
}
|
||||
for _, medi := range medias {
|
||||
if medi.Type == description.MediaTypeVideo && medi.Profile != headers.TransportProfileSAVP {
|
||||
return errSecureUDPUnavailable
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// udpReadBufferTarget is the UDP socket read buffer requested for RTP over
|
||||
// UDP. The OS default (around 208 KiB on Linux) drops packets on
|
||||
// high-bitrate main streams.
|
||||
const udpReadBufferTarget = 4 * 1024 * 1024
|
||||
|
||||
// rmemMaxPath holds the largest receive buffer an unprivileged socket may use.
|
||||
const rmemMaxPath = "/proc/sys/net/core/rmem_max"
|
||||
|
||||
// udpReadBufferSize returns the UDP read buffer to request: the target,
|
||||
// capped at the OS limit rmemMax. gortsplib fails the SETUP when it cannot get
|
||||
// the exact size it asked for, so the size must never exceed the limit. It
|
||||
// returns 0 (OS default) for TCP, or when the limit is unknown or not above the
|
||||
// default.
|
||||
func udpReadBufferSize(protocol *gortsplib.Protocol, rmemMax int) int {
|
||||
if protocol != nil && *protocol == gortsplib.ProtocolTCP {
|
||||
return 0
|
||||
}
|
||||
if rmemMax <= 0 {
|
||||
return 0
|
||||
}
|
||||
if rmemMax < udpReadBufferTarget {
|
||||
return rmemMax
|
||||
}
|
||||
return udpReadBufferTarget
|
||||
}
|
||||
|
||||
// readRmemMax reads the OS receive buffer limit, or 0 when it is unavailable
|
||||
// (non-Linux systems or a restricted /proc).
|
||||
func readRmemMax() int {
|
||||
data, err := os.ReadFile(rmemMaxPath)
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
value, err := strconv.Atoi(strings.TrimSpace(string(data)))
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
func rtspsTLSConfig() (*tls.Config, error) {
|
||||
if os.Getenv(rtspsInsecureEnv) == "true" {
|
||||
return &tls.Config{InsecureSkipVerify: true}, nil // #nosec G402 -- explicit opt-in for cameras with self-signed certificates
|
||||
@@ -97,6 +196,8 @@ func sanitizeRTSPError(err error, rawURL string) error {
|
||||
type Golibrtsp struct {
|
||||
RTSPClient
|
||||
Url string
|
||||
// Transport selects the RTSP transport: "tcp" (default), "udp" or "auto".
|
||||
Transport string
|
||||
|
||||
Client gortsplib.Client
|
||||
clientStarted bool
|
||||
@@ -546,12 +647,22 @@ func (g *Golibrtsp) Connect(ctx context.Context, ctxOtel context.Context) (err e
|
||||
return fmt.Errorf("configure RTSPS TLS: %w", err)
|
||||
}
|
||||
|
||||
protocol := gortsplib.ProtocolTCP
|
||||
g.health = newStreamHealth()
|
||||
protocol := rtspProtocol(g.Transport)
|
||||
g.Client = gortsplib.Client{
|
||||
RequestBackChannels: false,
|
||||
Protocol: &protocol,
|
||||
Protocol: protocol,
|
||||
UDPReadBufferSize: udpReadBufferSize(protocol, readRmemMax()),
|
||||
TLSConfig: tlsConfig,
|
||||
// In "auto" mode gortsplib may move from UDP to TCP; report it through
|
||||
// the structured logger instead of gortsplib's plain stdout logging.
|
||||
OnTransportSwitch: func(err error) {
|
||||
log.WithFields(log.Fields{
|
||||
"component": "capture",
|
||||
"event": "rtsp_transport_switch",
|
||||
"stream": g.streamLabel,
|
||||
}).Warn("RTSP transport switched: " + err.Error())
|
||||
},
|
||||
// Route gortsplib's packet-loss / decode-error reporting through our
|
||||
// structured logger with stream context (replaces its plain stdout
|
||||
// logging). These hooks are what let us tell whether the camera is
|
||||
@@ -585,6 +696,10 @@ func (g *Golibrtsp) Connect(ctx context.Context, ctxOtel context.Context) (err e
|
||||
return sanitizeRTSPError(err, g.Url)
|
||||
}
|
||||
|
||||
if err = checkSecureUDP(u.Scheme, protocol, desc.Medias); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Initialize the mutex and FPS calculation.
|
||||
g.VideoDecoderMutex = &sync.Mutex{}
|
||||
g.initFPSCalculation()
|
||||
@@ -822,6 +937,27 @@ func (g *Golibrtsp) Connect(ctx context.Context, ctxOtel context.Context) (err e
|
||||
return
|
||||
}
|
||||
|
||||
// logNegotiatedTransport logs the transport that SETUP agreed on, which can
|
||||
// differ from the configured one in "auto" mode. A later UDP to TCP switch
|
||||
// (no packets received in time) is reported by OnTransportSwitch.
|
||||
func (g *Golibrtsp) logNegotiatedTransport() {
|
||||
transport := g.Client.Transport()
|
||||
if transport == nil || transport.Session == nil {
|
||||
return
|
||||
}
|
||||
configured := strings.ToLower(strings.TrimSpace(g.Transport))
|
||||
if configured == "" {
|
||||
configured = RTSPTransportTCP
|
||||
}
|
||||
log.WithFields(log.Fields{
|
||||
"component": "capture",
|
||||
"event": "rtsp_transport",
|
||||
"stream": g.streamLabel,
|
||||
"configured": configured,
|
||||
"negotiated": transport.Session.Protocol.String(),
|
||||
}).Info("RTSP transport negotiated")
|
||||
}
|
||||
|
||||
func (g *Golibrtsp) ConnectBackChannel(ctx context.Context, ctxRunAgent context.Context) (err error) {
|
||||
|
||||
_, span := tracer.Start(ctxRunAgent, "ConnectBackChannel")
|
||||
@@ -832,11 +968,9 @@ func (g *Golibrtsp) ConnectBackChannel(ctx context.Context, ctxRunAgent context.
|
||||
return fmt.Errorf("configure RTSPS TLS: %w", err)
|
||||
}
|
||||
|
||||
// Transport TCP
|
||||
protocol := gortsplib.ProtocolTCP
|
||||
g.Client = gortsplib.Client{
|
||||
RequestBackChannels: true,
|
||||
Protocol: &protocol,
|
||||
Protocol: backChannelProtocol(),
|
||||
TLSConfig: tlsConfig,
|
||||
}
|
||||
// parse URL
|
||||
@@ -956,6 +1090,7 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
|
||||
if g.health == nil {
|
||||
g.health = newStreamHealth()
|
||||
}
|
||||
g.logNegotiatedTransport()
|
||||
|
||||
// called when a MULAW audio RTP packet arrives
|
||||
if g.AudioG711Media != nil && g.AudioG711Forma != nil {
|
||||
|
||||
@@ -12,6 +12,9 @@ import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/bluenviron/gortsplib/v5"
|
||||
"github.com/bluenviron/gortsplib/v5/pkg/description"
|
||||
"github.com/bluenviron/gortsplib/v5/pkg/headers"
|
||||
"github.com/bluenviron/mediacommon/pkg/codecs/h264"
|
||||
)
|
||||
|
||||
@@ -247,3 +250,100 @@ func TestH264FrameNumTrackerHonorsPermittedGaps(t *testing.T) {
|
||||
func testH264Slice(naluType h264.NALUType, frameNum uint32) []byte {
|
||||
return []byte{0x60 | byte(naluType), 0xE0 | byte(frameNum&0x1F)}
|
||||
}
|
||||
|
||||
func TestRTSPProtocol(t *testing.T) {
|
||||
tcp := gortsplib.ProtocolTCP
|
||||
udp := gortsplib.ProtocolUDP
|
||||
tests := []struct {
|
||||
transport string
|
||||
want *gortsplib.Protocol
|
||||
}{
|
||||
{transport: "", want: &tcp},
|
||||
{transport: "tcp", want: &tcp},
|
||||
{transport: " TCP ", want: &tcp},
|
||||
{transport: "udp", want: &udp},
|
||||
{transport: "UDP", want: &udp},
|
||||
{transport: "auto", want: nil},
|
||||
{transport: "Auto", want: nil},
|
||||
{transport: "bogus", want: &tcp},
|
||||
}
|
||||
for _, test := range tests {
|
||||
t.Run(test.transport, func(t *testing.T) {
|
||||
got := rtspProtocol(test.transport)
|
||||
if test.want == nil {
|
||||
if got != nil {
|
||||
t.Fatalf("rtspProtocol(%q) = %v, want nil (auto)", test.transport, *got)
|
||||
}
|
||||
return
|
||||
}
|
||||
if got == nil || *got != *test.want {
|
||||
t.Fatalf("rtspProtocol(%q) = %v, want %v", test.transport, got, *test.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestBackChannelProtocolIsTCP(t *testing.T) {
|
||||
if got := backChannelProtocol(); got == nil || *got != gortsplib.ProtocolTCP {
|
||||
t.Fatalf("backChannelProtocol() = %v, want tcp", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCheckSecureUDP(t *testing.T) {
|
||||
tcp := gortsplib.ProtocolTCP
|
||||
udp := gortsplib.ProtocolUDP
|
||||
plainVideo := []*description.Media{
|
||||
{Type: description.MediaTypeVideo, Profile: headers.TransportProfileAVP},
|
||||
}
|
||||
srtpVideo := []*description.Media{
|
||||
{Type: description.MediaTypeVideo, Profile: headers.TransportProfileSAVP},
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
scheme string
|
||||
protocol *gortsplib.Protocol
|
||||
medias []*description.Media
|
||||
wantErr bool
|
||||
}{
|
||||
{name: "rtsps udp plain video", scheme: "rtsps", protocol: &udp, medias: plainVideo, wantErr: true},
|
||||
{name: "rtsps udp srtp video", scheme: "rtsps", protocol: &udp, medias: srtpVideo},
|
||||
{name: "rtsps tcp", scheme: "rtsps", protocol: &tcp, medias: plainVideo},
|
||||
{name: "rtsps auto", scheme: "rtsps", protocol: nil, medias: plainVideo},
|
||||
{name: "rtsp udp", scheme: "rtsp", protocol: &udp, medias: plainVideo},
|
||||
}
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
err := checkSecureUDP(test.scheme, test.protocol, test.medias)
|
||||
if test.wantErr && !errors.Is(err, errSecureUDPUnavailable) {
|
||||
t.Fatalf("checkSecureUDP() = %v, want errSecureUDPUnavailable", err)
|
||||
}
|
||||
if !test.wantErr && err != nil {
|
||||
t.Fatalf("checkSecureUDP() = %v, want nil", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUDPReadBufferSize(t *testing.T) {
|
||||
tcp := gortsplib.ProtocolTCP
|
||||
udp := gortsplib.ProtocolUDP
|
||||
tests := []struct {
|
||||
name string
|
||||
protocol *gortsplib.Protocol
|
||||
rmemMax int
|
||||
want int
|
||||
}{
|
||||
{name: "tcp keeps os default", protocol: &tcp, rmemMax: 8 << 20, want: 0},
|
||||
{name: "unknown limit keeps os default", protocol: &udp, rmemMax: 0, want: 0},
|
||||
{name: "default linux limit", protocol: &udp, rmemMax: 212992, want: 212992},
|
||||
{name: "raised limit capped at target", protocol: &udp, rmemMax: 16 << 20, want: udpReadBufferTarget},
|
||||
{name: "auto uses target", protocol: nil, rmemMax: 16 << 20, want: udpReadBufferTarget},
|
||||
}
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
if got := udpReadBufferSize(test.protocol, test.rmemMax); got != test.want {
|
||||
t.Fatalf("udpReadBufferSize() = %d, want %d", got, test.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -858,7 +858,8 @@ func VerifyCamera(c *gin.Context) {
|
||||
// Currently only support H264 encoded cameras, this will change.
|
||||
// Establishing the camera connection without backchannel if no substream
|
||||
rtspClient := &Golibrtsp{
|
||||
Url: rtspUrl,
|
||||
Url: rtspUrl,
|
||||
Transport: cameraStreams.RTSPTransport,
|
||||
}
|
||||
|
||||
err := rtspClient.Connect(ctx, ctxVerifyCamera)
|
||||
|
||||
@@ -1503,9 +1503,9 @@ func VerifyHub(c *gin.Context, configuredHubURI string) {
|
||||
tr := &http.Transport{
|
||||
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
|
||||
}
|
||||
client = &http.Client{Transport: tr, CheckRedirect: rejectHubVerificationRedirect}
|
||||
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
|
||||
} else {
|
||||
client = &http.Client{CheckRedirect: rejectHubVerificationRedirect}
|
||||
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
|
||||
}
|
||||
|
||||
resp, err := client.Do(req)
|
||||
@@ -1554,7 +1554,7 @@ func VerifyHub(c *gin.Context, configuredHubURI string) {
|
||||
// @Summary Will verify the persistence.
|
||||
// @Description Will verify the persistence.
|
||||
// @Success 200 {object} models.APIResponse
|
||||
func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string) {
|
||||
func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI, configuredVaultURI string) {
|
||||
|
||||
var config models.Config
|
||||
err := c.BindJSON(&config)
|
||||
@@ -1610,9 +1610,9 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
|
||||
tr := &http.Transport{
|
||||
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
|
||||
}
|
||||
client = &http.Client{Transport: tr, CheckRedirect: rejectHubVerificationRedirect}
|
||||
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
|
||||
} else {
|
||||
client = &http.Client{CheckRedirect: rejectHubVerificationRedirect}
|
||||
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
|
||||
}
|
||||
|
||||
resp, err := client.Do(req)
|
||||
@@ -1655,18 +1655,27 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
|
||||
provider := config.KStorage.Provider
|
||||
|
||||
if err == nil && uri != "" && accessKey != "" && secretAccessKey != "" {
|
||||
vaultURI, uriErr := configuredVaultVerificationURI(uri, configuredVaultURI)
|
||||
if uriErr != nil {
|
||||
msg := "cloud.VerifyPersistence(kerberosvault): " + uriErr.Error()
|
||||
log.Error(msg)
|
||||
c.JSON(http.StatusBadRequest, models.APIResponse{
|
||||
Data: msg,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
var client *http.Client
|
||||
if os.Getenv("AGENT_TLS_INSECURE") == "true" {
|
||||
tr := &http.Transport{
|
||||
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
|
||||
}
|
||||
client = &http.Client{Transport: tr}
|
||||
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
|
||||
} else {
|
||||
client = &http.Client{}
|
||||
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
|
||||
}
|
||||
|
||||
req, err := http.NewRequest("POST", uri+"/ping", nil)
|
||||
req, err := http.NewRequest("POST", vaultURI+"/ping", nil)
|
||||
if err == nil {
|
||||
req.Header.Add("X-Kerberos-Storage-AccessKey", accessKey)
|
||||
req.Header.Add("X-Kerberos-Storage-SecretAccessKey", secretAccessKey)
|
||||
@@ -1695,7 +1704,7 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
|
||||
}
|
||||
defer file.Close()
|
||||
|
||||
req, err := http.NewRequest("POST", uri+"/storage", file)
|
||||
req, err := http.NewRequest("POST", vaultURI+"/storage", file)
|
||||
if err == nil {
|
||||
|
||||
req.Header.Set("Content-Type", "video/mp4")
|
||||
@@ -1713,9 +1722,9 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
|
||||
tr := &http.Transport{
|
||||
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
|
||||
}
|
||||
client = &http.Client{Transport: tr}
|
||||
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
|
||||
} else {
|
||||
client = &http.Client{}
|
||||
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
|
||||
}
|
||||
|
||||
resp, err := client.Do(req)
|
||||
@@ -1807,19 +1816,30 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
|
||||
}
|
||||
}
|
||||
|
||||
func configuredHubVerificationURI(requested, configured string) (string, error) {
|
||||
// configuredVerificationURI only lets a verify request reach the endpoint that
|
||||
// is already saved in the agent configuration. It returns the saved value, not
|
||||
// the requested one, so credentials are never sent to a URI from the request body.
|
||||
func configuredVerificationURI(target, requested, configured string) (string, error) {
|
||||
requested = strings.TrimRight(strings.TrimSpace(requested), "/")
|
||||
configured = strings.TrimRight(strings.TrimSpace(configured), "/")
|
||||
if configured == "" {
|
||||
return "", errors.New("save the Hub URI before verifying it")
|
||||
return "", errors.New("save the " + target + " URI before verifying it")
|
||||
}
|
||||
if requested != configured {
|
||||
return "", errors.New("the Hub URI does not match the saved configuration; save it before verifying")
|
||||
return "", errors.New("the " + target + " URI does not match the saved configuration; save it before verifying")
|
||||
}
|
||||
return configured, nil
|
||||
}
|
||||
|
||||
func rejectHubVerificationRedirect(_ *http.Request, _ []*http.Request) error {
|
||||
func configuredHubVerificationURI(requested, configured string) (string, error) {
|
||||
return configuredVerificationURI("Hub", requested, configured)
|
||||
}
|
||||
|
||||
func configuredVaultVerificationURI(requested, configured string) (string, error) {
|
||||
return configuredVerificationURI("Kerberos Vault", requested, configured)
|
||||
}
|
||||
|
||||
func rejectVerificationRedirect(_ *http.Request, _ []*http.Request) error {
|
||||
return http.ErrUseLastResponse
|
||||
}
|
||||
|
||||
@@ -1850,7 +1870,7 @@ func hubPersistenceVerificationError(statusCode int) string {
|
||||
// @Summary Will verify the secondary persistence.
|
||||
// @Description Will verify the secondary persistence.
|
||||
// @Success 200 {object} models.APIResponse
|
||||
func VerifySecondaryPersistence(c *gin.Context, configDirectory string) {
|
||||
func VerifySecondaryPersistence(c *gin.Context, configDirectory, configuredVaultURI string) {
|
||||
|
||||
var config models.Config
|
||||
err := c.BindJSON(&config)
|
||||
@@ -1874,18 +1894,27 @@ func VerifySecondaryPersistence(c *gin.Context, configDirectory string) {
|
||||
provider := config.KStorageSecondary.Provider
|
||||
|
||||
if err == nil && uri != "" && accessKey != "" && secretAccessKey != "" {
|
||||
vaultURI, uriErr := configuredVaultVerificationURI(uri, configuredVaultURI)
|
||||
if uriErr != nil {
|
||||
msg := "cloud.VerifySecondaryPersistence(kerberosvault): " + uriErr.Error()
|
||||
log.Error(msg)
|
||||
c.JSON(http.StatusBadRequest, models.APIResponse{
|
||||
Data: msg,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
var client *http.Client
|
||||
if os.Getenv("AGENT_TLS_INSECURE") == "true" {
|
||||
tr := &http.Transport{
|
||||
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
|
||||
}
|
||||
client = &http.Client{Transport: tr}
|
||||
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
|
||||
} else {
|
||||
client = &http.Client{}
|
||||
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
|
||||
}
|
||||
|
||||
req, err := http.NewRequest("POST", uri+"/ping", nil)
|
||||
req, err := http.NewRequest("POST", vaultURI+"/ping", nil)
|
||||
if err == nil {
|
||||
req.Header.Add("X-Kerberos-Storage-AccessKey", accessKey)
|
||||
req.Header.Add("X-Kerberos-Storage-SecretAccessKey", secretAccessKey)
|
||||
@@ -1914,7 +1943,7 @@ func VerifySecondaryPersistence(c *gin.Context, configDirectory string) {
|
||||
}
|
||||
defer file.Close()
|
||||
|
||||
req, err := http.NewRequest("POST", uri+"/storage", file)
|
||||
req, err := http.NewRequest("POST", vaultURI+"/storage", file)
|
||||
if err == nil {
|
||||
|
||||
req.Header.Set("Content-Type", "video/mp4")
|
||||
@@ -1932,9 +1961,9 @@ func VerifySecondaryPersistence(c *gin.Context, configDirectory string) {
|
||||
tr := &http.Transport{
|
||||
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
|
||||
}
|
||||
client = &http.Client{Transport: tr}
|
||||
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
|
||||
} else {
|
||||
client = &http.Client{}
|
||||
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
|
||||
}
|
||||
|
||||
resp, err := client.Do(req)
|
||||
|
||||
@@ -53,7 +53,7 @@ func TestVerifyPersistenceKerberosHubUsesAuthorizationHead(t *testing.T) {
|
||||
ctx.Request = httptest.NewRequest(http.MethodPost, "/api/persistence/verify", bytes.NewReader(payload))
|
||||
ctx.Request.Header.Set("Content-Type", "application/json")
|
||||
|
||||
VerifyPersistence(ctx, t.TempDir(), server.URL)
|
||||
VerifyPersistence(ctx, t.TempDir(), server.URL, "")
|
||||
|
||||
if recorder.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, body = %s", recorder.Code, recorder.Body.String())
|
||||
@@ -112,7 +112,7 @@ func TestVerifyPersistenceKerberosHubRejectsCrossHostRedirect(t *testing.T) {
|
||||
ctx.Request = httptest.NewRequest(http.MethodPost, "/api/persistence/verify", bytes.NewReader(payload))
|
||||
ctx.Request.Header.Set("Content-Type", "application/json")
|
||||
|
||||
VerifyPersistence(ctx, t.TempDir(), hub.URL)
|
||||
VerifyPersistence(ctx, t.TempDir(), hub.URL, "")
|
||||
|
||||
if recorder.Code != http.StatusBadRequest {
|
||||
t.Fatalf("status = %d, want %d; body = %s", recorder.Code, http.StatusBadRequest, recorder.Body.String())
|
||||
@@ -155,7 +155,7 @@ func TestVerifyPersistenceKerberosHubRejectsUnsavedURI(t *testing.T) {
|
||||
ctx.Request = httptest.NewRequest(http.MethodPost, "/api/persistence/verify", bytes.NewReader(payload))
|
||||
ctx.Request.Header.Set("Content-Type", "application/json")
|
||||
|
||||
VerifyPersistence(ctx, t.TempDir(), "https://saved-hub.example.com")
|
||||
VerifyPersistence(ctx, t.TempDir(), "https://saved-hub.example.com", "")
|
||||
|
||||
if recorder.Code != http.StatusBadRequest {
|
||||
t.Fatalf("status = %d, want %d; body = %s", recorder.Code, http.StatusBadRequest, recorder.Body.String())
|
||||
@@ -199,6 +199,129 @@ func TestVerifyHubRejectsUnsavedURI(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func vaultVerifyContext(t *testing.T, path string, config models.Config) (*gin.Context, *httptest.ResponseRecorder) {
|
||||
t.Helper()
|
||||
payload, err := json.Marshal(config)
|
||||
if err != nil {
|
||||
t.Fatalf("json.Marshal() error = %v", err)
|
||||
}
|
||||
gin.SetMode(gin.TestMode)
|
||||
recorder := httptest.NewRecorder()
|
||||
ctx, _ := gin.CreateTestContext(recorder)
|
||||
ctx.Request = httptest.NewRequest(http.MethodPost, path, bytes.NewReader(payload))
|
||||
ctx.Request.Header.Set("Content-Type", "application/json")
|
||||
return ctx, recorder
|
||||
}
|
||||
|
||||
func vaultStorage(uri string) *models.KStorage {
|
||||
return &models.KStorage{
|
||||
URI: uri,
|
||||
AccessKey: "vault-access",
|
||||
SecretAccessKey: "vault-secret",
|
||||
Provider: "minio",
|
||||
Directory: "camera-1",
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerifyPersistenceVaultRejectsUnsavedURI(t *testing.T) {
|
||||
requestCount := 0
|
||||
untrusted := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
||||
requestCount++
|
||||
w.WriteHeader(http.StatusOK)
|
||||
}))
|
||||
defer untrusted.Close()
|
||||
|
||||
ctx, recorder := vaultVerifyContext(t, "/api/persistence/verify", models.Config{
|
||||
Cloud: "kerberosvault",
|
||||
KStorage: vaultStorage(untrusted.URL),
|
||||
})
|
||||
|
||||
VerifyPersistence(ctx, t.TempDir(), "", "https://saved-vault.example.com")
|
||||
|
||||
if recorder.Code != http.StatusBadRequest {
|
||||
t.Fatalf("status = %d, want %d; body = %s", recorder.Code, http.StatusBadRequest, recorder.Body.String())
|
||||
}
|
||||
if requestCount != 0 {
|
||||
t.Fatalf("untrusted Vault received %d requests, want none", requestCount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerifySecondaryPersistenceVaultRejectsUnsavedURI(t *testing.T) {
|
||||
requestCount := 0
|
||||
untrusted := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
||||
requestCount++
|
||||
w.WriteHeader(http.StatusOK)
|
||||
}))
|
||||
defer untrusted.Close()
|
||||
|
||||
ctx, recorder := vaultVerifyContext(t, "/api/persistence/secondary/verify", models.Config{
|
||||
Cloud: "kerberosvault",
|
||||
KStorageSecondary: vaultStorage(untrusted.URL),
|
||||
})
|
||||
|
||||
VerifySecondaryPersistence(ctx, t.TempDir(), "")
|
||||
|
||||
if recorder.Code != http.StatusBadRequest {
|
||||
t.Fatalf("status = %d, want %d; body = %s", recorder.Code, http.StatusBadRequest, recorder.Body.String())
|
||||
}
|
||||
if requestCount != 0 {
|
||||
t.Fatalf("untrusted Vault received %d requests, want none", requestCount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerifyPersistenceVaultUsesSavedURI(t *testing.T) {
|
||||
var pingHeaders http.Header
|
||||
vault := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path == "/ping" {
|
||||
pingHeaders = r.Header.Clone()
|
||||
}
|
||||
w.WriteHeader(http.StatusInternalServerError)
|
||||
}))
|
||||
defer vault.Close()
|
||||
|
||||
ctx, _ := vaultVerifyContext(t, "/api/persistence/verify", models.Config{
|
||||
Cloud: "kerberosvault",
|
||||
KStorage: vaultStorage(vault.URL + "/"),
|
||||
})
|
||||
|
||||
VerifyPersistence(ctx, t.TempDir(), "", vault.URL)
|
||||
|
||||
if pingHeaders == nil {
|
||||
t.Fatal("saved Vault did not receive the /ping request")
|
||||
}
|
||||
if got := pingHeaders.Get("X-Kerberos-Storage-AccessKey"); got != "vault-access" {
|
||||
t.Fatalf("X-Kerberos-Storage-AccessKey = %q, want %q", got, "vault-access")
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerifySecondaryPersistenceVaultRejectsCrossHostRedirect(t *testing.T) {
|
||||
var redirectedHeaders http.Header
|
||||
target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
redirectedHeaders = r.Header.Clone()
|
||||
w.WriteHeader(http.StatusOK)
|
||||
}))
|
||||
defer target.Close()
|
||||
|
||||
vault := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
http.Redirect(w, r, target.URL+r.URL.Path, http.StatusTemporaryRedirect)
|
||||
}))
|
||||
defer vault.Close()
|
||||
|
||||
ctx, recorder := vaultVerifyContext(t, "/api/persistence/secondary/verify", models.Config{
|
||||
Cloud: "kerberosvault",
|
||||
KStorageSecondary: vaultStorage(vault.URL),
|
||||
})
|
||||
|
||||
VerifySecondaryPersistence(ctx, t.TempDir(), vault.URL)
|
||||
|
||||
if recorder.Code != http.StatusBadRequest {
|
||||
t.Fatalf("status = %d, want %d; body = %s", recorder.Code, http.StatusBadRequest, recorder.Body.String())
|
||||
}
|
||||
if redirectedHeaders != nil {
|
||||
t.Fatalf("redirect target received a request with X-Kerberos-Storage-SecretAccessKey=%q", redirectedHeaders.Get("X-Kerberos-Storage-SecretAccessKey"))
|
||||
}
|
||||
}
|
||||
|
||||
func TestHubPersistenceVerificationErrorExplainsStatus(t *testing.T) {
|
||||
for _, test := range []struct {
|
||||
status int
|
||||
|
||||
@@ -16,7 +16,7 @@ import (
|
||||
"github.com/kerberos-io/agent/machinery/src/cloud/livemoq"
|
||||
"github.com/kerberos-io/agent/machinery/src/models"
|
||||
"github.com/kerberos-io/agent/machinery/src/packets"
|
||||
"github.com/moq-dev/moq-go/moq"
|
||||
"moq.dev/moq"
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
@@ -292,7 +292,7 @@ func publishLiveStreamMoQ(ctx context.Context, config liveMoQConfig) error {
|
||||
}
|
||||
defer finishBroadcast()
|
||||
|
||||
stream, err := broadcast.PublishMedia("avc3", nil)
|
||||
stream, err := broadcast.PublishVideo(moq.VideoFormatAvc3, nil)
|
||||
if err != nil {
|
||||
return fmt.Errorf("create H.264 media stream: %w", err)
|
||||
}
|
||||
|
||||
@@ -12,7 +12,7 @@ import (
|
||||
|
||||
"github.com/kerberos-io/agent/machinery/src/cloud/livemoq"
|
||||
"github.com/kerberos-io/agent/machinery/src/models"
|
||||
"github.com/moq-dev/moq-go/moq"
|
||||
"moq.dev/moq"
|
||||
)
|
||||
|
||||
func TestCloseLiveMoQPublisherFinishesBeforeClosingClient(t *testing.T) {
|
||||
@@ -155,7 +155,7 @@ func TestNativeMoQClientCloseStopsActiveWriter(t *testing.T) {
|
||||
server.Close()
|
||||
t.Fatal(err)
|
||||
}
|
||||
stream, err := broadcast.PublishMedia("avc3", nil)
|
||||
stream, err := broadcast.PublishVideo(moq.VideoFormatAvc3, nil)
|
||||
if err != nil {
|
||||
client.Close()
|
||||
server.Close()
|
||||
|
||||
@@ -59,11 +59,13 @@ func UploadS3(configuration *models.Configuration, fileName string) (bool, bool,
|
||||
|
||||
// Check if we need to use the proxy.
|
||||
if config.S3.ProxyURI != "" {
|
||||
var transport http.RoundTripper = &http.Transport{
|
||||
transport := &http.Transport{
|
||||
Proxy: func(*http.Request) (*url.URL, error) {
|
||||
return url.Parse(config.S3.ProxyURI)
|
||||
},
|
||||
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
|
||||
}
|
||||
if os.Getenv("AGENT_TLS_INSECURE") == "true" {
|
||||
transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
|
||||
}
|
||||
s3Client.SetCustomTransport(transport)
|
||||
}
|
||||
|
||||
@@ -207,6 +207,7 @@ func RunAgent(parent context.Context, configDirectory string, configuration *mod
|
||||
// Establishing the camera connection without backchannel if no substream
|
||||
rtspUrl := mainRTSP
|
||||
rtspClient = captureDevice.SetMainClient(rtspUrl)
|
||||
rtspClient.Transport = config.Capture.IPCamera.RTSPTransport
|
||||
run.SetMainClient(rtspClient)
|
||||
if rtspUrl != "" {
|
||||
err := rtspClient.Connect(run.Context(), ctxRunAgent)
|
||||
@@ -316,6 +317,7 @@ func RunAgent(parent context.Context, configDirectory string, configuration *mod
|
||||
// For the sub stream we will not enable backchannel.
|
||||
subStreamEnabled = true
|
||||
rtspSubClient = captureDevice.SetSubClient(subRtspUrl)
|
||||
rtspSubClient.Transport = config.Capture.IPCamera.RTSPTransport
|
||||
|
||||
run.SetSubClient(rtspSubClient)
|
||||
|
||||
@@ -436,6 +438,7 @@ func RunAgent(parent context.Context, configDirectory string, configuration *mod
|
||||
// Try to create backchannel
|
||||
communication.HasBackChannel.Store(false)
|
||||
rtspBackChannelClient = captureDevice.SetBackChannelClient(rtspUrl)
|
||||
rtspBackChannelClient.Transport = config.Capture.IPCamera.RTSPTransport
|
||||
run.SetBackchannelClient(rtspBackChannelClient)
|
||||
err = rtspBackChannelClient.ConnectBackChannel(run.Context(), ctxRunAgent)
|
||||
if err == nil {
|
||||
|
||||
@@ -369,6 +369,11 @@ func applyAgentEnvVars(configuration *models.Configuration, prefix string, apply
|
||||
case "AGENT_CAPTURE_IPCAMERA_RTSP":
|
||||
configuration.Config.Capture.IPCamera.RTSP = value
|
||||
break
|
||||
|
||||
case "AGENT_CAPTURE_IPCAMERA_RTSP_TRANSPORT":
|
||||
configuration.Config.Capture.IPCamera.RTSPTransport = value
|
||||
break
|
||||
|
||||
case "AGENT_CAPTURE_IPCAMERA_SUB_RTSP":
|
||||
configuration.Config.Capture.IPCamera.SubRTSP = value
|
||||
break
|
||||
|
||||
@@ -104,6 +104,18 @@ func TestApplyAgentEnvVarsVaultCustomHeaders(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyAgentEnvVarsRTSPTransport(t *testing.T) {
|
||||
t.Setenv("AGENT_CAPTURE_IPCAMERA_RTSP_TRANSPORT", "udp")
|
||||
configuration := &models.Configuration{}
|
||||
initConfigPointers(&configuration.Config)
|
||||
|
||||
applyAgentEnvVars(configuration, "", false)
|
||||
|
||||
if got := configuration.Config.Capture.IPCamera.RTSPTransport; got != "udp" {
|
||||
t.Fatalf("RTSPTransport = %q, want udp", got)
|
||||
}
|
||||
}
|
||||
|
||||
func intPointer(value int) *int {
|
||||
return &value
|
||||
}
|
||||
|
||||
@@ -18,6 +18,8 @@ type OnvifCredentials struct {
|
||||
type CameraStreams struct {
|
||||
RTSP string `json:"rtsp"`
|
||||
SubRTSP string `json:"sub_rtsp"`
|
||||
// RTSPTransport is optional: "tcp" (default), "udp" or "auto".
|
||||
RTSPTransport string `json:"rtsp_transport,omitempty"`
|
||||
}
|
||||
|
||||
// DiscoveredDevice describes a device found on the local network during a
|
||||
|
||||
@@ -93,6 +93,10 @@ type IPCamera struct {
|
||||
Height int `json:"height"`
|
||||
FPS string `json:"fps"`
|
||||
|
||||
// RTSPTransport selects the transport used for RTSP media: "tcp"
|
||||
// (default), "udp" or "auto" (UDP first, falling back to TCP).
|
||||
RTSPTransport string `json:"rtsp_transport,omitempty" bson:"rtsp_transport,omitempty"`
|
||||
|
||||
SubRTSP string `json:"sub_rtsp"`
|
||||
SubWidth int `json:"sub_width"`
|
||||
SubHeight int `json:"sub_height"`
|
||||
|
||||
@@ -16,7 +16,7 @@ import (
|
||||
func TestHealthCheckReturnsStandardPublicResponse(t *testing.T) {
|
||||
gin.SetMode(gin.TestMode)
|
||||
|
||||
middlewareConfig := JWTMiddleWare()
|
||||
middlewareConfig := JWTMiddleWare(t.TempDir())
|
||||
authMiddleware, err := jwt.New(&middlewareConfig)
|
||||
if err != nil {
|
||||
t.Fatalf("initialize JWT middleware: %v", err)
|
||||
|
||||
@@ -11,21 +11,17 @@ import (
|
||||
"github.com/kerberos-io/agent/machinery/src/models"
|
||||
)
|
||||
|
||||
func JWTMiddleWare() jwt.GinJWTMiddleware {
|
||||
func JWTMiddleWare(configDirectory string) jwt.GinJWTMiddleware {
|
||||
|
||||
identityKey := "id"
|
||||
// Allow the JWT signing secret to be configured through an environment
|
||||
// variable so that tokens issued by another service (e.g. the Kerberos
|
||||
// Factory) can be validated by the agent. Falls back to the historic
|
||||
// default to preserve backwards compatibility.
|
||||
myKey := os.Getenv("AGENT_JWT_SECRET")
|
||||
if myKey == "" {
|
||||
myKey = "TOBECHANGED"
|
||||
}
|
||||
// AGENT_JWT_SECRET lets tokens issued by another service (e.g. the
|
||||
// Kerberos Factory) be validated by the agent. Without it, a random secret
|
||||
// is generated once and stored with the configuration; see loadJWTSecret.
|
||||
myKey := loadJWTSecret(configDirectory)
|
||||
|
||||
m := jwt.GinJWTMiddleware{
|
||||
Realm: "kerberosio",
|
||||
Key: []byte(myKey),
|
||||
Key: myKey,
|
||||
Timeout: time.Hour * 24,
|
||||
MaxRefresh: time.Hour * 24 * 7,
|
||||
IdentityKey: identityKey,
|
||||
@@ -39,10 +35,15 @@ func JWTMiddleWare() jwt.GinJWTMiddleware {
|
||||
},
|
||||
IdentityHandler: func(c *gin.Context) interface{} {
|
||||
claims := jwt.ExtractClaims(c)
|
||||
user := claims["id"].(map[string]interface{})
|
||||
user, ok := claims["id"].(map[string]interface{})
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
username, _ := user["username"].(string)
|
||||
role, _ := user["role"].(string)
|
||||
return &models.User{
|
||||
Username: user["username"].(string),
|
||||
Role: user["role"].(string),
|
||||
Username: username,
|
||||
Role: role,
|
||||
}
|
||||
},
|
||||
Authenticator: func(c *gin.Context) (interface{}, error) {
|
||||
@@ -53,11 +54,7 @@ func JWTMiddleWare() jwt.GinJWTMiddleware {
|
||||
username := loginVals.Username
|
||||
password := loginVals.Password
|
||||
|
||||
// Get username from ENV
|
||||
usernameFromConfig := os.Getenv("AGENT_USERNAME")
|
||||
if usernameFromConfig == "" {
|
||||
usernameFromConfig = "root"
|
||||
}
|
||||
usernameFromConfig := agentUsername()
|
||||
// Get password from ENV
|
||||
passwordFromConfig := os.Getenv("AGENT_PASSWORD")
|
||||
if passwordFromConfig == "" {
|
||||
@@ -76,7 +73,7 @@ func JWTMiddleWare() jwt.GinJWTMiddleware {
|
||||
LoginResponse: func(c *gin.Context, code int, token string, expire time.Time) {
|
||||
|
||||
// Decrypt the token
|
||||
hmacSecret := []byte(myKey) // todo in config file
|
||||
hmacSecret := myKey
|
||||
t, _ := jwtgo.Parse(token, func(token *jwtgo.Token) (interface{}, error) {
|
||||
return hmacSecret, nil
|
||||
})
|
||||
@@ -94,10 +91,10 @@ func JWTMiddleWare() jwt.GinJWTMiddleware {
|
||||
})
|
||||
},
|
||||
Authorizator: func(data interface{}, c *gin.Context) bool {
|
||||
if _, ok := data.(*models.User); ok { //&& v.Username == "admin" {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
// Only the configured account may use the API, even with a
|
||||
// validly signed token.
|
||||
user, ok := data.(*models.User)
|
||||
return ok && user.Username != "" && user.Username == agentUsername()
|
||||
},
|
||||
Unauthorized: func(c *gin.Context, code int, message string) {
|
||||
c.AbortWithStatusJSON(code, gin.H{
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
package http
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
const (
|
||||
// jwtSecretFileName lives next to config.json so it persists on the same
|
||||
// volume and survives restarts and upgrades.
|
||||
jwtSecretFileName = "jwt_secret"
|
||||
// minJWTSecretLength is the shortest persisted secret that is accepted.
|
||||
// Generated secrets are 64 hex characters (32 random bytes).
|
||||
minJWTSecretLength = 32
|
||||
// legacyJWTSecret was the hard-coded fallback in earlier releases. It is
|
||||
// public, so it is never used implicitly.
|
||||
legacyJWTSecret = "TOBECHANGED"
|
||||
)
|
||||
|
||||
// loadJWTSecret returns the key used to sign and verify API tokens.
|
||||
//
|
||||
// AGENT_JWT_SECRET always wins, so deployments that share a secret with
|
||||
// another service (such as Kerberos Factory) keep working. Without it, a
|
||||
// random secret is generated on first start and stored in
|
||||
// <configDirectory>/data/config/jwt_secret. If that file cannot be written,
|
||||
// an in-memory random secret is used, which means users must sign in again
|
||||
// after a restart.
|
||||
func loadJWTSecret(configDirectory string) []byte {
|
||||
if secret := os.Getenv("AGENT_JWT_SECRET"); secret != "" {
|
||||
if secret == legacyJWTSecret {
|
||||
log.WithFields(log.Fields{
|
||||
"component": "http",
|
||||
"event": "jwt_secret_insecure",
|
||||
}).Warn("AGENT_JWT_SECRET is set to the publicly known legacy default; set a random value")
|
||||
}
|
||||
return []byte(secret)
|
||||
}
|
||||
|
||||
path := filepath.Join(configDirectory, "data", "config", jwtSecretFileName)
|
||||
if data, err := os.ReadFile(path); err == nil {
|
||||
secret := strings.TrimSpace(string(data))
|
||||
if len(secret) >= minJWTSecretLength {
|
||||
return []byte(secret)
|
||||
}
|
||||
log.WithFields(log.Fields{
|
||||
"component": "http",
|
||||
"event": "jwt_secret_invalid",
|
||||
"path": path,
|
||||
}).Warn("Stored JWT secret is too short; generating a new one")
|
||||
} else if !errors.Is(err, os.ErrNotExist) {
|
||||
log.WithError(err).WithFields(log.Fields{
|
||||
"component": "http",
|
||||
"event": "jwt_secret_read_failed",
|
||||
"path": path,
|
||||
}).Warn("Could not read stored JWT secret; generating a new one")
|
||||
}
|
||||
|
||||
secret, err := randomJWTSecret()
|
||||
if err != nil {
|
||||
log.WithError(err).WithFields(log.Fields{
|
||||
"component": "http",
|
||||
"event": "jwt_secret_generation_failed",
|
||||
}).Fatal("Could not generate a JWT signing secret")
|
||||
}
|
||||
|
||||
if err := writeJWTSecret(path, secret); err != nil {
|
||||
log.WithError(err).WithFields(log.Fields{
|
||||
"component": "http",
|
||||
"event": "jwt_secret_persist_failed",
|
||||
"path": path,
|
||||
}).Warn("Could not store the generated JWT secret; sessions will not survive a restart")
|
||||
} else {
|
||||
log.WithFields(log.Fields{
|
||||
"component": "http",
|
||||
"event": "jwt_secret_generated",
|
||||
"path": path,
|
||||
}).Info("Generated a new JWT signing secret")
|
||||
}
|
||||
return []byte(secret)
|
||||
}
|
||||
|
||||
func randomJWTSecret() (string, error) {
|
||||
buf := make([]byte, 32)
|
||||
if _, err := rand.Read(buf); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return hex.EncodeToString(buf), nil
|
||||
}
|
||||
|
||||
func writeJWTSecret(path, secret string) error {
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
|
||||
return err
|
||||
}
|
||||
tmp := path + ".tmp"
|
||||
if err := os.WriteFile(tmp, []byte(secret+"\n"), 0o600); err != nil {
|
||||
return err
|
||||
}
|
||||
return os.Rename(tmp, path)
|
||||
}
|
||||
|
||||
// agentUsername is the single account allowed to use the API.
|
||||
func agentUsername() string {
|
||||
if username := os.Getenv("AGENT_USERNAME"); username != "" {
|
||||
return username
|
||||
}
|
||||
return "root"
|
||||
}
|
||||
@@ -18,7 +18,10 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirect
|
||||
HealthCheck(c, communication)
|
||||
})
|
||||
|
||||
r.GET("/ws", func(c *gin.Context) {
|
||||
// The WebSocket carries the live camera stream, so it needs a token like
|
||||
// the API. Browsers cannot set headers on WebSocket requests, so the UI
|
||||
// passes it as the ?token= query parameter.
|
||||
r.GET("/ws", authMiddleware.MiddlewareFunc(), func(c *gin.Context) {
|
||||
websocket.WebsocketHandler(c, configuration, communication, captureDevice)
|
||||
})
|
||||
|
||||
@@ -70,12 +73,12 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirect
|
||||
|
||||
// Will verify the persistence settings.
|
||||
api.POST("/persistence/verify", func(c *gin.Context) {
|
||||
cloud.VerifyPersistence(c, configDirectory, configuration.Config.HubURI)
|
||||
cloud.VerifyPersistence(c, configDirectory, configuration.Config.HubURI, savedVaultURI(configuration.Config.KStorage))
|
||||
})
|
||||
|
||||
// Will verify the secondary persistence settings.
|
||||
api.POST("/persistence/secondary/verify", func(c *gin.Context) {
|
||||
cloud.VerifySecondaryPersistence(c, configDirectory)
|
||||
cloud.VerifySecondaryPersistence(c, configDirectory, savedVaultURI(configuration.Config.KStorageSecondary))
|
||||
})
|
||||
|
||||
// Camera specific methods.
|
||||
@@ -117,3 +120,12 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirect
|
||||
}
|
||||
return api
|
||||
}
|
||||
|
||||
// savedVaultURI returns the Kerberos Vault URI from the saved configuration,
|
||||
// which is the only endpoint a persistence verify request may contact.
|
||||
func savedVaultURI(storage *models.KStorage) string {
|
||||
if storage == nil {
|
||||
return ""
|
||||
}
|
||||
return storage.URI
|
||||
}
|
||||
|
||||
@@ -0,0 +1,204 @@
|
||||
package http
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
stdhttp "net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
jwt "github.com/appleboy/gin-jwt/v2"
|
||||
"github.com/gin-gonic/gin"
|
||||
jwtgo "github.com/golang-jwt/jwt/v4"
|
||||
"github.com/kerberos-io/agent/machinery/src/models"
|
||||
)
|
||||
|
||||
func TestLoadJWTSecretPrefersEnvironment(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
t.Setenv("AGENT_JWT_SECRET", "shared-with-factory")
|
||||
|
||||
if got := string(loadJWTSecret(dir)); got != "shared-with-factory" {
|
||||
t.Fatalf("loadJWTSecret() = %q, want the AGENT_JWT_SECRET value", got)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(dir, "data", "config", jwtSecretFileName)); !os.IsNotExist(err) {
|
||||
t.Fatalf("no secret file should be written when AGENT_JWT_SECRET is set, stat err = %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadJWTSecretGeneratesAndPersistsRandomSecret(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
t.Setenv("AGENT_JWT_SECRET", "")
|
||||
|
||||
first := string(loadJWTSecret(dir))
|
||||
if first == legacyJWTSecret || len(first) != 64 {
|
||||
t.Fatalf("generated secret = %q, want 64 random hex characters", first)
|
||||
}
|
||||
|
||||
path := filepath.Join(dir, "data", "config", jwtSecretFileName)
|
||||
info, err := os.Stat(path)
|
||||
if err != nil {
|
||||
t.Fatalf("secret file not written: %v", err)
|
||||
}
|
||||
if perm := info.Mode().Perm(); perm != 0o600 {
|
||||
t.Fatalf("secret file permissions = %o, want 600", perm)
|
||||
}
|
||||
|
||||
if second := string(loadJWTSecret(dir)); second != first {
|
||||
t.Fatalf("secret changed across restarts: %q then %q", first, second)
|
||||
}
|
||||
if other := string(loadJWTSecret(t.TempDir())); other == first {
|
||||
t.Fatal("two installs generated the same secret")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadJWTSecretReplacesShortStoredSecret(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
t.Setenv("AGENT_JWT_SECRET", "")
|
||||
path := filepath.Join(dir, "data", "config", jwtSecretFileName)
|
||||
if err := writeJWTSecret(path, legacyJWTSecret); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
got := string(loadJWTSecret(dir))
|
||||
if got == legacyJWTSecret || len(got) != 64 {
|
||||
t.Fatalf("short stored secret was reused: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
// securityRouter wires the real middleware and routes the way StartServer does.
|
||||
func securityRouter(t *testing.T) (*gin.Engine, []byte) {
|
||||
t.Helper()
|
||||
gin.SetMode(gin.TestMode)
|
||||
t.Setenv("AGENT_JWT_SECRET", "")
|
||||
t.Setenv("AGENT_USERNAME", "")
|
||||
t.Setenv("AGENT_PASSWORD", "")
|
||||
|
||||
dir := t.TempDir()
|
||||
config := JWTMiddleWare(dir)
|
||||
authMiddleware, err := jwt.New(&config)
|
||||
if err != nil {
|
||||
t.Fatalf("initialize JWT middleware: %v", err)
|
||||
}
|
||||
|
||||
router := gin.New()
|
||||
router.Use(gin.Recovery())
|
||||
registerProfiler(router, authMiddleware)
|
||||
AddRoutes(router, authMiddleware, dir, &models.Configuration{}, &models.Communication{}, nil)
|
||||
registerFileRoute(router, authMiddleware, dir, &models.Configuration{})
|
||||
return router, config.Key
|
||||
}
|
||||
|
||||
func signedToken(t *testing.T, key []byte, username string) string {
|
||||
t.Helper()
|
||||
token := jwtgo.NewWithClaims(jwtgo.SigningMethodHS256, jwtgo.MapClaims{
|
||||
"id": map[string]interface{}{"username": username, "role": "admin"},
|
||||
"exp": time.Now().Add(time.Hour).Unix(),
|
||||
"orig_iat": time.Now().Unix(),
|
||||
})
|
||||
signed, err := token.SignedString(key)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return signed
|
||||
}
|
||||
|
||||
func request(router *gin.Engine, method, target, bearer string) int {
|
||||
req := httptest.NewRequest(method, target, nil)
|
||||
if bearer != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+bearer)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
router.ServeHTTP(rec, req)
|
||||
return rec.Code
|
||||
}
|
||||
|
||||
func TestAPIRejectsTokensSignedWithLegacyDefaultKey(t *testing.T) {
|
||||
router, _ := securityRouter(t)
|
||||
forged := signedToken(t, []byte(legacyJWTSecret), "root")
|
||||
|
||||
if code := request(router, "GET", "/api/config", forged); code != stdhttp.StatusUnauthorized {
|
||||
t.Fatalf("token signed with the legacy key: status %d, want 401", code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAPIRejectsTokensForOtherUsers(t *testing.T) {
|
||||
router, key := securityRouter(t)
|
||||
other := signedToken(t, key, "intruder")
|
||||
|
||||
if code := request(router, "GET", "/api/config", other); code != stdhttp.StatusForbidden {
|
||||
t.Fatalf("validly signed token for another user: status %d, want 403", code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoginTokenGrantsAccess(t *testing.T) {
|
||||
router, _ := securityRouter(t)
|
||||
|
||||
req := httptest.NewRequest("POST", "/api/login", strings.NewReader(`{"username":"root","password":"root"}`))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
rec := httptest.NewRecorder()
|
||||
router.ServeHTTP(rec, req)
|
||||
if rec.Code != stdhttp.StatusOK {
|
||||
t.Fatalf("login: status %d, body %s", rec.Code, rec.Body.String())
|
||||
}
|
||||
var body struct {
|
||||
Token string `json:"token"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil || body.Token == "" {
|
||||
t.Fatalf("login response without token: %s", rec.Body.String())
|
||||
}
|
||||
|
||||
if code := request(router, "GET", "/file/missing.mp4?token="+body.Token, ""); code == stdhttp.StatusUnauthorized || code == stdhttp.StatusForbidden {
|
||||
t.Fatalf("login token rejected on /file: status %d", code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRecordingsRequireToken(t *testing.T) {
|
||||
router, key := securityRouter(t)
|
||||
|
||||
if code := request(router, "GET", "/file/recording.mp4", ""); code != stdhttp.StatusUnauthorized {
|
||||
t.Fatalf("/file without token: status %d, want 401", code)
|
||||
}
|
||||
// With a valid token the handler runs and reports the missing file.
|
||||
token := signedToken(t, key, "root")
|
||||
if code := request(router, "GET", "/file/recording.mp4?token="+token, ""); code != stdhttp.StatusNotFound {
|
||||
t.Fatalf("/file with ?token=: status %d, want 404 from the handler", code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLiveWebSocketRequiresToken(t *testing.T) {
|
||||
router, key := securityRouter(t)
|
||||
|
||||
if code := request(router, "GET", "/ws", ""); code != stdhttp.StatusUnauthorized {
|
||||
t.Fatalf("/ws without token: status %d, want 401", code)
|
||||
}
|
||||
// With a valid token the request reaches the upgrader, which rejects a
|
||||
// non-WebSocket request itself.
|
||||
token := signedToken(t, key, "root")
|
||||
if code := request(router, "GET", "/ws?token="+token, ""); code == stdhttp.StatusUnauthorized || code == stdhttp.StatusForbidden {
|
||||
t.Fatalf("/ws with ?token=: status %d, want the request to pass authentication", code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestProfilerDisabledByDefault(t *testing.T) {
|
||||
t.Setenv("AGENT_ENABLE_PPROF", "")
|
||||
router, key := securityRouter(t)
|
||||
|
||||
if code := request(router, "GET", "/debug/pprof/", signedToken(t, key, "root")); code != stdhttp.StatusNotFound {
|
||||
t.Fatalf("pprof without AGENT_ENABLE_PPROF: status %d, want 404", code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestProfilerRequiresTokenWhenEnabled(t *testing.T) {
|
||||
t.Setenv("AGENT_ENABLE_PPROF", "true")
|
||||
router, key := securityRouter(t)
|
||||
|
||||
if code := request(router, "GET", "/debug/pprof/", ""); code != stdhttp.StatusUnauthorized {
|
||||
t.Fatalf("enabled pprof without token: status %d, want 401", code)
|
||||
}
|
||||
if code := request(router, "GET", "/debug/pprof/", signedToken(t, key, "root")); code != stdhttp.StatusOK {
|
||||
t.Fatalf("enabled pprof with token: status %d, want 200", code)
|
||||
}
|
||||
}
|
||||
@@ -61,17 +61,14 @@ func StartServer(configDirectory string, configuration *models.Configuration, co
|
||||
c.AbortWithStatus(500)
|
||||
}))
|
||||
|
||||
// Profiler
|
||||
pprof.Register(r)
|
||||
|
||||
// Setup CORS
|
||||
r.Use(CORS())
|
||||
|
||||
// Add Swagger
|
||||
r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
|
||||
|
||||
// The JWT middlewareergreggre
|
||||
middleWare := JWTMiddleWare()
|
||||
// The JWT middleware
|
||||
middleWare := JWTMiddleWare(configDirectory)
|
||||
authMiddleware, err := jwt.New(&middleWare)
|
||||
if err != nil {
|
||||
log.WithError(err).WithFields(log.Fields{
|
||||
@@ -80,6 +77,8 @@ func StartServer(configDirectory string, configuration *models.Configuration, co
|
||||
}).Fatal("Failed to initialize JWT middleware")
|
||||
}
|
||||
|
||||
registerProfiler(r, authMiddleware)
|
||||
|
||||
// Add all routes
|
||||
AddRoutes(r, authMiddleware, configDirectory, configuration, communication, captureDevice)
|
||||
|
||||
@@ -103,9 +102,7 @@ func StartServer(configDirectory string, configuration *models.Configuration, co
|
||||
r.Use(static.Serve("/media", static.LocalFile(configDirectory+"/www", true)))
|
||||
r.Use(static.Serve("/settings", static.LocalFile(configDirectory+"/www", true)))
|
||||
r.Use(static.Serve("/login", static.LocalFile(configDirectory+"/www", true)))
|
||||
r.Handle("GET", "/file/*filepath", func(c *gin.Context) {
|
||||
Files(c, configDirectory, configuration)
|
||||
})
|
||||
registerFileRoute(r, authMiddleware, configDirectory, configuration)
|
||||
|
||||
// Run the api on port
|
||||
log.WithFields(log.Fields{
|
||||
@@ -123,6 +120,23 @@ func StartServer(configDirectory string, configuration *models.Configuration, co
|
||||
}
|
||||
}
|
||||
|
||||
// registerProfiler exposes the Go profiler only when AGENT_ENABLE_PPROF=true.
|
||||
// The endpoints expose heap dumps (which can contain credentials) and can be
|
||||
// used to exhaust the CPU, so they always require a valid token.
|
||||
func registerProfiler(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware) {
|
||||
if os.Getenv("AGENT_ENABLE_PPROF") == "true" {
|
||||
pprof.Register(r.Group("", authMiddleware.MiddlewareFunc()))
|
||||
}
|
||||
}
|
||||
|
||||
// registerFileRoute serves recordings to signed-in users. Browsers load them
|
||||
// through <video src>, so the UI passes the token as ?token=.
|
||||
func registerFileRoute(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirectory string, configuration *models.Configuration) {
|
||||
r.Handle("GET", "/file/*filepath", authMiddleware.MiddlewareFunc(), func(c *gin.Context) {
|
||||
Files(c, configDirectory, configuration)
|
||||
})
|
||||
}
|
||||
|
||||
func requestLogger() gin.HandlerFunc {
|
||||
return func(c *gin.Context) {
|
||||
startedAt := time.Now()
|
||||
@@ -196,7 +210,6 @@ func Files(c *gin.Context, configDirectory string, configuration *models.Configu
|
||||
fileSize := len(contents)
|
||||
|
||||
// Send file to gin
|
||||
c.Header("Access-Control-Allow-Origin", "*")
|
||||
c.Header("Content-Disposition", "attachment; filename="+filePath)
|
||||
c.Header("Content-Type", "video/mp4")
|
||||
c.Header("Content-Length", strconv.Itoa(fileSize))
|
||||
|
||||
@@ -860,7 +860,10 @@ func HandleVerifyStream(mqttClient mqtt.Client, hubKey string, payload models.Pa
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
||||
defer cancel()
|
||||
|
||||
rtspClient := &capture.Golibrtsp{Url: rtspUrl}
|
||||
rtspClient := &capture.Golibrtsp{
|
||||
Url: rtspUrl,
|
||||
Transport: configuration.Config.Capture.IPCamera.RTSPTransport,
|
||||
}
|
||||
errConnect := rtspClient.Connect(ctx, ctx)
|
||||
if errConnect != nil {
|
||||
errMsg = errConnect.Error()
|
||||
|
||||
+1
-1
@@ -12,7 +12,7 @@
|
||||
"@testing-library/jest-dom": "^5.16.5",
|
||||
"@testing-library/react": "^11.2.7",
|
||||
"@testing-library/user-event": "^12.8.3",
|
||||
"axios": "^0.33.0",
|
||||
"axios": "^0.34.0",
|
||||
"classnames": "^2.3.1",
|
||||
"connected-react-router": "^6.9.3",
|
||||
"eslint-config-prettier": "8.5.*",
|
||||
|
||||
@@ -103,6 +103,11 @@
|
||||
"only_h264": "Currently only H264/H265 RTSP streams are supported.",
|
||||
"rtsp_url": "RTSP URL",
|
||||
"rtsp_h264": "A H264/H265 RTSP connection to your camera.",
|
||||
"rtsp_transport": "RTSP transport",
|
||||
"rtsp_transport_select": "Select RTSP transport",
|
||||
"rtsp_transport_tcp": "TCP (reliable, default)",
|
||||
"rtsp_transport_udp": "UDP (low latency)",
|
||||
"rtsp_transport_auto": "Auto (UDP, fall back to TCP)",
|
||||
"sub_rtsp_url": "Sub RTSP URL (used for livestreaming)",
|
||||
"sub_rtsp_h264": "A secondary RTSP connection to the low resolution of your camera.",
|
||||
"onvif": "ONVIF",
|
||||
|
||||
+7
-1
@@ -24,6 +24,7 @@ import { connect } from 'react-redux';
|
||||
import { Link } from 'react-router-dom';
|
||||
import { logout } from './actions';
|
||||
import config from './config';
|
||||
import { getToken, withToken } from './api/api';
|
||||
import { getDashboardInformation } from './actions/agent';
|
||||
import LanguageSelect from './components/LanguageSelect/LanguageSelect';
|
||||
import websocketClientId from './websocket';
|
||||
@@ -260,7 +261,12 @@ const mapStateToProps = (state) => ({
|
||||
const mapDispatchToProps = (dispatch) => ({
|
||||
dispatchLogout: () => dispatch(logout()),
|
||||
dispatchConnect: () => {
|
||||
dispatch(connectWS(config.WS_URL));
|
||||
// The WebSocket requires a token; there is nothing to connect to before
|
||||
// sign-in (App mounts briefly on first load before the login redirect).
|
||||
if (!getToken()) {
|
||||
return;
|
||||
}
|
||||
dispatch(connectWS(withToken(config.WS_URL)));
|
||||
},
|
||||
dispatchDisconnect: () => dispatch(disconnectWS()),
|
||||
dispatchSend: (message) => dispatch(send(message)),
|
||||
|
||||
@@ -134,11 +134,14 @@ export function doVerifyCamera(streamType, config, onSuccess, onError) {
|
||||
const cameraStreams = {
|
||||
rtsp: '',
|
||||
sub_rtsp: '',
|
||||
rtsp_transport: '',
|
||||
};
|
||||
|
||||
if (config) {
|
||||
cameraStreams.rtsp = config.capture.ipcamera.rtsp;
|
||||
cameraStreams.sub_rtsp = config.capture.ipcamera.sub_rtsp;
|
||||
cameraStreams.rtsp_transport =
|
||||
config.capture.ipcamera.rtsp_transport || '';
|
||||
}
|
||||
|
||||
const endpoint = API.post(`camera/verify/${streamType}`, cameraStreams);
|
||||
|
||||
@@ -16,6 +16,18 @@ export function getToken() {
|
||||
return localStorage.getItem('token');
|
||||
}
|
||||
|
||||
// Browsers cannot attach an Authorization header to WebSocket connections or
|
||||
// to media elements such as <video src>, so those URLs carry the token as the
|
||||
// ?token= query parameter, which the agent's JWT middleware also accepts.
|
||||
export function withToken(url) {
|
||||
const token = getToken();
|
||||
if (!token) {
|
||||
return url;
|
||||
}
|
||||
const separator = url.includes('?') ? '&' : '?';
|
||||
return `${url}${separator}token=${encodeURIComponent(token)}`;
|
||||
}
|
||||
|
||||
export function getAPIObject(url) {
|
||||
return {
|
||||
url: config.API_URL + url,
|
||||
|
||||
@@ -26,6 +26,7 @@ import {
|
||||
import './Dashboard.scss';
|
||||
import ReactTooltip from 'react-tooltip';
|
||||
import config from '../../config';
|
||||
import { withToken } from '../../api/api';
|
||||
import { getConfig } from '../../actions/agent';
|
||||
|
||||
function createUUID() {
|
||||
@@ -426,7 +427,7 @@ class Dashboard extends React.Component {
|
||||
}
|
||||
};
|
||||
|
||||
this.webrtcSocket = new WebSocket(config.WS_URL);
|
||||
this.webrtcSocket = new WebSocket(withToken(config.WS_URL));
|
||||
this.webrtcSocket.onopen = () => {
|
||||
this.sendWebRTCMessage('hello', {});
|
||||
};
|
||||
@@ -612,7 +613,7 @@ class Dashboard extends React.Component {
|
||||
className="time"
|
||||
onClick={() =>
|
||||
this.openModal(
|
||||
`${config.URL}/file/${event.key}`
|
||||
withToken(`${config.URL}/file/${event.key}`)
|
||||
)
|
||||
}
|
||||
>
|
||||
@@ -625,7 +626,7 @@ class Dashboard extends React.Component {
|
||||
className="pointer event-description"
|
||||
onClick={() =>
|
||||
this.openModal(
|
||||
`${config.URL}/file/${event.key}`
|
||||
withToken(`${config.URL}/file/${event.key}`)
|
||||
)
|
||||
}
|
||||
>
|
||||
|
||||
@@ -15,6 +15,7 @@ import { Link, withRouter } from 'react-router-dom';
|
||||
import { connect } from 'react-redux';
|
||||
import { getEvents } from '../../actions/agent';
|
||||
import config from '../../config';
|
||||
import { withToken } from '../../api/api';
|
||||
import './Media.scss';
|
||||
|
||||
function formatDateTimeLocal(date) {
|
||||
@@ -258,11 +259,13 @@ class Media extends React.Component {
|
||||
{events.map((event) => (
|
||||
<div
|
||||
key={event.key}
|
||||
onClick={() => this.openModal(`${config.URL}/file/${event.key}`)}
|
||||
onClick={() =>
|
||||
this.openModal(withToken(`${config.URL}/file/${event.key}`))
|
||||
}
|
||||
>
|
||||
<VideoCard
|
||||
isMediaWall
|
||||
videoSrc={`${config.URL}/file/${event.key}`}
|
||||
videoSrc={withToken(`${config.URL}/file/${event.key}`)}
|
||||
hours={event.time}
|
||||
month={event.short_day}
|
||||
videoStatus=""
|
||||
|
||||
@@ -1074,6 +1074,34 @@ export class Settings extends React.Component {
|
||||
)
|
||||
}
|
||||
/>
|
||||
<Dropdown
|
||||
isRadio
|
||||
label={t('settings.camera.rtsp_transport')}
|
||||
placeholder={t('settings.camera.rtsp_transport_select')}
|
||||
items={[
|
||||
{
|
||||
label: t('settings.camera.rtsp_transport_tcp'),
|
||||
value: 'tcp',
|
||||
},
|
||||
{
|
||||
label: t('settings.camera.rtsp_transport_udp'),
|
||||
value: 'udp',
|
||||
},
|
||||
{
|
||||
label: t('settings.camera.rtsp_transport_auto'),
|
||||
value: 'auto',
|
||||
},
|
||||
]}
|
||||
selected={[config.capture.ipcamera.rtsp_transport || 'tcp']}
|
||||
onChange={(value) =>
|
||||
this.onUpdateDropdown(
|
||||
'capture.ipcamera',
|
||||
'rtsp_transport',
|
||||
value[0],
|
||||
config.capture.ipcamera
|
||||
)
|
||||
}
|
||||
/>
|
||||
</BlockBody>
|
||||
<BlockFooter>
|
||||
{config.capture.ipcamera &&
|
||||
|
||||
+258
-258
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user