Compare commits

..
Author SHA1 Message Date
Cédric VerstraetenandClaude Opus 5.5 485ec02c55 ui: address lint findings in the Vite migration
- vite.config.mjs: disable import/no-unresolved; eslint-plugin-import 2.x
  cannot resolve packages that only define "exports" (vite, plugin-react)
- ui/README.md: turn the scripts table into a list to keep lines short
- README.md: wrap the edited UI paragraph

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 21:38:12 +00:00
Cédric Verstraeten 00398a4dd7 Merge branch 'fix/dependabot-alerts' into feat/ui-vite 2026-11-21 21:37:08 +00:00
Cédric VerstraetenandClaude Opus 5.5 7e8431c11c ui: install @kerberos-io/ui 1.77.1 from its GitHub release
Replace the vendored tarball with the one attached to the kerberos-io/ui
v1.77.1 GitHub release, as uug-ai/factory already does. That tarball is
built by the ui repo's release workflow and ships with a .sha256 file
(e9f94f44...); yarn.lock pins it by hash.

Its JS is identical to the locally built tarball, and its CSS differs
only in selector order within @extend-generated rules.

This removes ui/vendor and the extra COPY line in the Dockerfile.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 20:58:37 +00:00
Cédric VerstraetenandClaude Opus 5.5 6cd077daa3 ui: vendor @kerberos-io/ui 1.77.1 to clear the last Dependabot alerts
@kerberos-io/ui 1.77.1 moves its build tools (@svgr/webpack,
svg-react-loader, sass-loader, Storybook, Rollup plugins) out of its
runtime dependencies. Those pulled svgo 1 and decode-uri-component 0.2
into the agent's lockfile.

1.77.1 is tagged on GitHub but was never published to npm, so install
it from a tarball built from kerberos-io/ui@ae1faa7 (tag v1.77.1) and
committed under ui/vendor. Compared with the published 1.77.0 the
exports are identical; the only code change is the bundled uuid (8 -> 11).

The Dockerfile copies ui/vendor before `yarn --frozen-lockfile`.
ui/vendor/README.md records the checksum and how to switch back to the
registry once a fixed version is published.

Clears the remaining 5 Dependabot alerts (svgo, decode-uri-component).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 20:42:30 +00:00
Cédric VerstraetenandClaude Opus 5.5 6c49611211 ui: migrate from Create React App to Vite
react-scripts 5 is unmaintained and pins vulnerable versions of
webpack-dev-server, webpack-dev-middleware, postcss 7 and svgo.

- build and dev server: Vite 8 with @vitejs/plugin-react
- tests: Vitest 4 with jsdom (jest.* -> vi.*; mocked default exports
  now return { default })
- index.html moves to ui/ and loads src/index.jsx as a module
- REACT_APP_ENVIRONMENT is replaced by import.meta.env.PROD/MODE, and
  REACT_APP_AGENT_API_PORT is renamed to VITE_AGENT_API_PORT
- bundled output goes to static/ so it does not mix with public/assets
- package.json is not "type": "module": that would switch CommonJS
  interop to Node semantics and break default imports such as
  @giantmachines/redux-websocket
- sass 1.54 -> 1.108 (Vite needs the modern compiler API); sass-loader
  removed
- requires Node >= 20.19

`yarn build` still writes to machinery/www, so the Dockerfile and CI
workflow are unchanged.

Clears the remaining 9 react-scripts Dependabot alerts. Five alerts for
svgo 1 and decode-uri-component 0.2 remain; they come from build-tool
dependencies of @kerberos-io/ui and are not part of the bundle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 20:18:54 +00:00
37 changed files with 453 additions and 1313 deletions
+4
View File
@@ -1,5 +1,9 @@
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 \
+24 -34
View File
@@ -22,12 +22,10 @@ env:
jobs:
# Determine the next version, create the GitHub release and expose the tag.
bump-release:
# 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
uses: uug-ai/workflows/.github/workflows/release-bump.yml@main
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).
@@ -58,9 +56,6 @@ 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
@@ -71,16 +66,16 @@ jobs:
uses: actions/checkout@v4
- name: Run Build
run: |
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}"
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}
- name: Strip binary
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
- name: Build and push Docker image
run: |
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
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 }}
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
@@ -95,9 +90,6 @@ 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
@@ -108,16 +100,16 @@ jobs:
uses: actions/checkout@v4
- name: Run Build
run: |
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}"
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}
- name: Strip binary
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
- name: Build and push Docker image
run: |
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
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 }}
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
@@ -127,8 +119,6 @@ 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
@@ -137,16 +127,16 @@ jobs:
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Create and push multi-arch manifest
run: |
docker manifest create "${REPO}:${RELEASE_TAG}" \
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
docker manifest push "${REPO}:${RELEASE_TAG}"
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 }}
- name: Create and push latest manifest
run: |
docker manifest create "${REPO}:latest" \
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
docker manifest push "${REPO}:latest"
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
create-release:
runs-on: ubuntu-24.04
+22 -41
View File
@@ -11,9 +11,6 @@ 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:
@@ -23,15 +20,7 @@ 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:
@@ -41,16 +30,16 @@ jobs:
uses: actions/checkout@v4
- name: Run Build
run: |
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}"
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}
- name: Strip binary
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
- name: Build and push Docker image
run: |
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
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}}
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
@@ -64,15 +53,7 @@ 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:
@@ -82,16 +63,16 @@ jobs:
uses: actions/checkout@v4
- name: Run Build
run: |
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}"
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}
- name: Strip binary
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
- name: Build and push Docker image
run: |
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
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}}
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
@@ -109,16 +90,16 @@ jobs:
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Create and push multi-arch manifest
run: |
docker manifest create "${REPO}:${RELEASE_TAG}" \
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
docker manifest push "${REPO}:${RELEASE_TAG}"
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 }}
- name: Create and push latest manifest
run: |
docker manifest create "${REPO}:latest" \
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
docker manifest push "${REPO}:latest"
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
if: github.event.inputs.tag == 'test'
create-release:
+4 -1
View File
@@ -1,5 +1,8 @@
ARG GO_IMAGE=golang:1.26-trixie
# 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 RUNTIME_IMAGE=debian:trixie-slim
ARG VERSION=0.0.0
FROM ${GO_IMAGE} AS build-machinery
-58
View File
@@ -1,58 +0,0 @@
# 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.
+54 -18
View File
@@ -61,7 +61,6 @@ 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
@@ -77,6 +76,60 @@ 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).
@@ -301,22 +354,6 @@ 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" |
@@ -338,7 +375,6 @@ Notes:
| `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
View File
@@ -27,6 +27,7 @@ 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
@@ -46,7 +47,6 @@ 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,6 +99,7 @@ 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
@@ -142,5 +143,4 @@ 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
View File
@@ -857,6 +857,10 @@ 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=
@@ -2170,10 +2174,6 @@ 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=
+5 -140
View File
@@ -32,7 +32,6 @@ 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"
@@ -51,104 +50,6 @@ 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
@@ -196,8 +97,6 @@ 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
@@ -647,22 +546,12 @@ 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,
UDPReadBufferSize: udpReadBufferSize(protocol, readRmemMax()),
Protocol: &protocol,
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
@@ -696,10 +585,6 @@ 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()
@@ -937,27 +822,6 @@ 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")
@@ -968,9 +832,11 @@ 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: backChannelProtocol(),
Protocol: &protocol,
TLSConfig: tlsConfig,
}
// parse URL
@@ -1090,7 +956,6 @@ 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 {
-100
View File
@@ -12,9 +12,6 @@ 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"
)
@@ -250,100 +247,3 @@ 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)
}
})
}
}
+1 -2
View File
@@ -858,8 +858,7 @@ 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,
Transport: cameraStreams.RTSPTransport,
Url: rtspUrl,
}
err := rtspClient.Connect(ctx, ctxVerifyCamera)
+22 -51
View File
@@ -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: rejectVerificationRedirect}
client = &http.Client{Transport: tr, CheckRedirect: rejectHubVerificationRedirect}
} else {
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
client = &http.Client{CheckRedirect: rejectHubVerificationRedirect}
}
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, configuredVaultURI string) {
func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string) {
var config models.Config
err := c.BindJSON(&config)
@@ -1610,9 +1610,9 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI, config
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
client = &http.Client{Transport: tr, CheckRedirect: rejectHubVerificationRedirect}
} else {
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
client = &http.Client{CheckRedirect: rejectHubVerificationRedirect}
}
resp, err := client.Do(req)
@@ -1655,27 +1655,18 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI, config
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, CheckRedirect: rejectVerificationRedirect}
client = &http.Client{Transport: tr}
} else {
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
client = &http.Client{}
}
req, err := http.NewRequest("POST", vaultURI+"/ping", nil)
req, err := http.NewRequest("POST", uri+"/ping", nil)
if err == nil {
req.Header.Add("X-Kerberos-Storage-AccessKey", accessKey)
req.Header.Add("X-Kerberos-Storage-SecretAccessKey", secretAccessKey)
@@ -1704,7 +1695,7 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI, config
}
defer file.Close()
req, err := http.NewRequest("POST", vaultURI+"/storage", file)
req, err := http.NewRequest("POST", uri+"/storage", file)
if err == nil {
req.Header.Set("Content-Type", "video/mp4")
@@ -1722,9 +1713,9 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI, config
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
client = &http.Client{Transport: tr}
} else {
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
client = &http.Client{}
}
resp, err := client.Do(req)
@@ -1816,30 +1807,19 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI, config
}
}
// 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) {
func configuredHubVerificationURI(requested, configured string) (string, error) {
requested = strings.TrimRight(strings.TrimSpace(requested), "/")
configured = strings.TrimRight(strings.TrimSpace(configured), "/")
if configured == "" {
return "", errors.New("save the " + target + " URI before verifying it")
return "", errors.New("save the Hub URI before verifying it")
}
if requested != configured {
return "", errors.New("the " + target + " URI does not match the saved configuration; save it before verifying")
return "", errors.New("the Hub URI does not match the saved configuration; save it before verifying")
}
return configured, nil
}
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 {
func rejectHubVerificationRedirect(_ *http.Request, _ []*http.Request) error {
return http.ErrUseLastResponse
}
@@ -1870,7 +1850,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, configuredVaultURI string) {
func VerifySecondaryPersistence(c *gin.Context, configDirectory string) {
var config models.Config
err := c.BindJSON(&config)
@@ -1894,27 +1874,18 @@ func VerifySecondaryPersistence(c *gin.Context, configDirectory, configuredVault
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, CheckRedirect: rejectVerificationRedirect}
client = &http.Client{Transport: tr}
} else {
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
client = &http.Client{}
}
req, err := http.NewRequest("POST", vaultURI+"/ping", nil)
req, err := http.NewRequest("POST", uri+"/ping", nil)
if err == nil {
req.Header.Add("X-Kerberos-Storage-AccessKey", accessKey)
req.Header.Add("X-Kerberos-Storage-SecretAccessKey", secretAccessKey)
@@ -1943,7 +1914,7 @@ func VerifySecondaryPersistence(c *gin.Context, configDirectory, configuredVault
}
defer file.Close()
req, err := http.NewRequest("POST", vaultURI+"/storage", file)
req, err := http.NewRequest("POST", uri+"/storage", file)
if err == nil {
req.Header.Set("Content-Type", "video/mp4")
@@ -1961,9 +1932,9 @@ func VerifySecondaryPersistence(c *gin.Context, configDirectory, configuredVault
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
client = &http.Client{Transport: tr}
} else {
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
client = &http.Client{}
}
resp, err := client.Do(req)
+3 -126
View File
@@ -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,129 +199,6 @@ 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
+2 -2
View File
@@ -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"
"moq.dev/moq"
"github.com/moq-dev/moq-go/moq"
log "github.com/sirupsen/logrus"
)
@@ -292,7 +292,7 @@ func publishLiveStreamMoQ(ctx context.Context, config liveMoQConfig) error {
}
defer finishBroadcast()
stream, err := broadcast.PublishVideo(moq.VideoFormatAvc3, nil)
stream, err := broadcast.PublishMedia("avc3", nil)
if err != nil {
return fmt.Errorf("create H.264 media stream: %w", err)
}
+2 -2
View File
@@ -12,7 +12,7 @@ import (
"github.com/kerberos-io/agent/machinery/src/cloud/livemoq"
"github.com/kerberos-io/agent/machinery/src/models"
"moq.dev/moq"
"github.com/moq-dev/moq-go/moq"
)
func TestCloseLiveMoQPublisherFinishesBeforeClosingClient(t *testing.T) {
@@ -155,7 +155,7 @@ func TestNativeMoQClientCloseStopsActiveWriter(t *testing.T) {
server.Close()
t.Fatal(err)
}
stream, err := broadcast.PublishVideo(moq.VideoFormatAvc3, nil)
stream, err := broadcast.PublishMedia("avc3", nil)
if err != nil {
client.Close()
server.Close()
+2 -4
View File
@@ -59,13 +59,11 @@ func UploadS3(configuration *models.Configuration, fileName string) (bool, bool,
// Check if we need to use the proxy.
if config.S3.ProxyURI != "" {
transport := &http.Transport{
var transport http.RoundTripper = &http.Transport{
Proxy: func(*http.Request) (*url.URL, error) {
return url.Parse(config.S3.ProxyURI)
},
}
if os.Getenv("AGENT_TLS_INSECURE") == "true" {
transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
s3Client.SetCustomTransport(transport)
}
-3
View File
@@ -207,7 +207,6 @@ 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)
@@ -317,7 +316,6 @@ 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)
@@ -438,7 +436,6 @@ 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 {
-5
View File
@@ -369,11 +369,6 @@ 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
-12
View File
@@ -104,18 +104,6 @@ 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
}
-2
View File
@@ -18,8 +18,6 @@ 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
-4
View File
@@ -93,10 +93,6 @@ 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"`
+1 -1
View File
@@ -16,7 +16,7 @@ import (
func TestHealthCheckReturnsStandardPublicResponse(t *testing.T) {
gin.SetMode(gin.TestMode)
middlewareConfig := JWTMiddleWare(t.TempDir())
middlewareConfig := JWTMiddleWare()
authMiddleware, err := jwt.New(&middlewareConfig)
if err != nil {
t.Fatalf("initialize JWT middleware: %v", err)
+23 -20
View File
@@ -11,17 +11,21 @@ import (
"github.com/kerberos-io/agent/machinery/src/models"
)
func JWTMiddleWare(configDirectory string) jwt.GinJWTMiddleware {
func JWTMiddleWare() jwt.GinJWTMiddleware {
identityKey := "id"
// 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)
// 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"
}
m := jwt.GinJWTMiddleware{
Realm: "kerberosio",
Key: myKey,
Key: []byte(myKey),
Timeout: time.Hour * 24,
MaxRefresh: time.Hour * 24 * 7,
IdentityKey: identityKey,
@@ -35,15 +39,10 @@ func JWTMiddleWare(configDirectory string) jwt.GinJWTMiddleware {
},
IdentityHandler: func(c *gin.Context) interface{} {
claims := jwt.ExtractClaims(c)
user, ok := claims["id"].(map[string]interface{})
if !ok {
return nil
}
username, _ := user["username"].(string)
role, _ := user["role"].(string)
user := claims["id"].(map[string]interface{})
return &models.User{
Username: username,
Role: role,
Username: user["username"].(string),
Role: user["role"].(string),
}
},
Authenticator: func(c *gin.Context) (interface{}, error) {
@@ -54,7 +53,11 @@ func JWTMiddleWare(configDirectory string) jwt.GinJWTMiddleware {
username := loginVals.Username
password := loginVals.Password
usernameFromConfig := agentUsername()
// Get username from ENV
usernameFromConfig := os.Getenv("AGENT_USERNAME")
if usernameFromConfig == "" {
usernameFromConfig = "root"
}
// Get password from ENV
passwordFromConfig := os.Getenv("AGENT_PASSWORD")
if passwordFromConfig == "" {
@@ -73,7 +76,7 @@ func JWTMiddleWare(configDirectory string) jwt.GinJWTMiddleware {
LoginResponse: func(c *gin.Context, code int, token string, expire time.Time) {
// Decrypt the token
hmacSecret := myKey
hmacSecret := []byte(myKey) // todo in config file
t, _ := jwtgo.Parse(token, func(token *jwtgo.Token) (interface{}, error) {
return hmacSecret, nil
})
@@ -91,10 +94,10 @@ func JWTMiddleWare(configDirectory string) jwt.GinJWTMiddleware {
})
},
Authorizator: func(data interface{}, c *gin.Context) bool {
// 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()
if _, ok := data.(*models.User); ok { //&& v.Username == "admin" {
return true
}
return false
},
Unauthorized: func(c *gin.Context, code int, message string) {
c.AbortWithStatusJSON(code, gin.H{
-113
View File
@@ -1,113 +0,0 @@
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"
}
+3 -15
View File
@@ -18,10 +18,7 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirect
HealthCheck(c, communication)
})
// 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) {
r.GET("/ws", func(c *gin.Context) {
websocket.WebsocketHandler(c, configuration, communication, captureDevice)
})
@@ -73,12 +70,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, savedVaultURI(configuration.Config.KStorage))
cloud.VerifyPersistence(c, configDirectory, configuration.Config.HubURI)
})
// Will verify the secondary persistence settings.
api.POST("/persistence/secondary/verify", func(c *gin.Context) {
cloud.VerifySecondaryPersistence(c, configDirectory, savedVaultURI(configuration.Config.KStorageSecondary))
cloud.VerifySecondaryPersistence(c, configDirectory)
})
// Camera specific methods.
@@ -120,12 +117,3 @@ 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
}
-204
View File
@@ -1,204 +0,0 @@
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)
}
}
+9 -22
View File
@@ -61,14 +61,17 @@ 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 middleware
middleWare := JWTMiddleWare(configDirectory)
// The JWT middlewareergreggre
middleWare := JWTMiddleWare()
authMiddleware, err := jwt.New(&middleWare)
if err != nil {
log.WithError(err).WithFields(log.Fields{
@@ -77,8 +80,6 @@ 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)
@@ -102,7 +103,9 @@ 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)))
registerFileRoute(r, authMiddleware, configDirectory, configuration)
r.Handle("GET", "/file/*filepath", func(c *gin.Context) {
Files(c, configDirectory, configuration)
})
// Run the api on port
log.WithFields(log.Fields{
@@ -120,23 +123,6 @@ 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()
@@ -210,6 +196,7 @@ 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))
+1 -4
View File
@@ -860,10 +860,7 @@ 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,
Transport: configuration.Config.Capture.IPCamera.RTSPTransport,
}
rtspClient := &capture.Golibrtsp{Url: rtspUrl}
errConnect := rtspClient.Connect(ctx, ctx)
if errConnect != nil {
errMsg = errConnect.Error()
+1 -1
View File
@@ -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.34.0",
"axios": "^0.33.0",
"classnames": "^2.3.1",
"connected-react-router": "^6.9.3",
"eslint-config-prettier": "8.5.*",
-5
View File
@@ -103,11 +103,6 @@
"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",
+1 -7
View File
@@ -24,7 +24,6 @@ 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';
@@ -261,12 +260,7 @@ const mapStateToProps = (state) => ({
const mapDispatchToProps = (dispatch) => ({
dispatchLogout: () => dispatch(logout()),
dispatchConnect: () => {
// 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)));
dispatch(connectWS(config.WS_URL));
},
dispatchDisconnect: () => dispatch(disconnectWS()),
dispatchSend: (message) => dispatch(send(message)),
-3
View File
@@ -134,14 +134,11 @@ 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);
-12
View File
@@ -16,18 +16,6 @@ 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,
+3 -4
View File
@@ -26,7 +26,6 @@ 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() {
@@ -427,7 +426,7 @@ class Dashboard extends React.Component {
}
};
this.webrtcSocket = new WebSocket(withToken(config.WS_URL));
this.webrtcSocket = new WebSocket(config.WS_URL);
this.webrtcSocket.onopen = () => {
this.sendWebRTCMessage('hello', {});
};
@@ -613,7 +612,7 @@ class Dashboard extends React.Component {
className="time"
onClick={() =>
this.openModal(
withToken(`${config.URL}/file/${event.key}`)
`${config.URL}/file/${event.key}`
)
}
>
@@ -626,7 +625,7 @@ class Dashboard extends React.Component {
className="pointer event-description"
onClick={() =>
this.openModal(
withToken(`${config.URL}/file/${event.key}`)
`${config.URL}/file/${event.key}`
)
}
>
+2 -5
View File
@@ -15,7 +15,6 @@ 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) {
@@ -259,13 +258,11 @@ class Media extends React.Component {
{events.map((event) => (
<div
key={event.key}
onClick={() =>
this.openModal(withToken(`${config.URL}/file/${event.key}`))
}
onClick={() => this.openModal(`${config.URL}/file/${event.key}`)}
>
<VideoCard
isMediaWall
videoSrc={withToken(`${config.URL}/file/${event.key}`)}
videoSrc={`${config.URL}/file/${event.key}`}
hours={event.time}
month={event.short_day}
videoStatus=""
-28
View File
@@ -1074,34 +1074,6 @@ 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
View File
File diff suppressed because it is too large Load Diff